Graphical program node for generating a measurement program

ABSTRACT

A system and method for performing a measurement task. A node is displayed in a graphical program, and configured to receive a measurement task specification (MTS). The node may be coupled to an MTS node, or to a configuration node which constructs the MTS at run time. When the program executes, the node receives the MTS, invokes an expert system to analyze the MTS, optionally validate the MTS, generates a run-time specification for the task. The node them invokes a run-time builder to analyze the run-time specification and generate a run-time based on the run-time specification, where the run-time is executable to perform the measurement task. The node may be a read node, a write node, or a start node connected to a read or write node. Additional operations may be performed prior to or during the first iteration, and/or during or after the last iteration, of the task.

CONTINUATION DATA

[0001] This application is a Continuation-in-Part of U.S. utilityapplication Ser. No. 10/008,792 titled “Measurement System SoftwareArchitecture for Easily Creating High-Performance MeasurementApplications” filed Nov. 13, 2001, whose inventors are Geoffrey Schmit,Brent Schwan, Jonathan Brumley, Thomas A. Makowski, and Christopher T.Bartz, which claims benefit of priority of U.S. provisional applicationSerial No. 60/301,785 titled “Measurement System Software Architecturefor Easily Creating High-Performance Measurement Applications” filedJun. 29, 2001, whose inventors are Geoffrey Schmit, Brent Schwan,Jonathan Brumley, Thomas A. Makowski, and Christopher T. Bartz.

BACKGROUND OF THE INVENTION

[0002] 1. Field of the Invention

[0003] The present invention relates generally to the field ofmeasurement and automation systems. More particularly, the presentinvention relates to a node in a graphical program which is useable togenerate an executable program for performing a measurement task.

[0004] 2. Description of the Related Art

[0005] Scientists and engineers often use measurement or automationsystems to perform a variety of functions, including measurement of aphysical phenomenon or unit under test (UUT), test and analysis ofphysical phenomena, simulation, hardware-in-the-loop testing, processmonitoring and control, control of mechanical or electrical machinery,data logging, laboratory research, and analytical chemistry, to name afew examples.

[0006] A typical measurement system includes a computer system with ameasurement device or measurement hardware. The measurement device maybe or include a computer-based instrument, a data acquisition device orboard, a programmable logic device (PLD), a sensor, a smart sensor, anactuator, a signal generator, or other type of device for acquiring orgenerating data. The measurement device may be a card or board pluggedinto one of the I/O slots of the computer system, a card or boardplugged into a chassis, or an external device. For example, in a commonmeasurement system configuration, the measurement hardware is coupled tothe computer system via other means such as through a VXI (VMEeXtensions for Instrumentation) bus, a PXI (PCI eXtensions forInstrumentation) bus, a GPIB (General Purpose Interface Bus), a serialport, or a parallel port of the computer system. Optionally, themeasurement system includes signal conditioning devices which receivethe field signals and condition the signals to be acquired.

[0007] A measurement system may also typically include transducers,sensors, actuators or other detecting (or generating) means forproviding “field” electrical signals representing a process, physicalphenomena, equipment being monitored or measured, etc. The field signalsare provided to the measurement hardware.

[0008] The measurement hardware is configured and controlled bymeasurement software executing on the computer system. The measurementsoftware for configuring and controlling the measurement systemtypically comprises two portions: the device interface or driver-levelsoftware and the application software, or the application. Thedriver-level software serves to interface the measurement hardware tothe application. The driver-level software may be supplied by themanufacturer of the measurement hardware or by some other third partysoftware vendor. An example of measurement or DAQ driver-level softwareis NI-DAQ from National Instruments Corporation. The application orclient is typically developed by the user of the measurement system andis tailored to the particular function which the user intends themeasurement system to perform. The measurement hardware manufacturer orthird party software vendor sometimes supplies the application softwarefor certain applications which are common, generic or straightforward.

[0009] One drawback of some current measurement system architectures isthat complex measurement tasks involving multiple devices require thateach device be programmed separately, and that synchronization signalsbe explicitly routed. Users must typically specify and configuremeasurement tasks at an advanced level, which is time consuming,expensive, and prone to error. For example, in some prior art systems,users must specify numerous parameter values for channels, timing, andtriggering for a measurement task. Typically there is no mechanism forproviding default values for the parameters, so that the user must notonly know all of the parameters which are needed to specify the task,but must also know what values of the parameters are appropriate for thetask. These issues may become more important when multiple devices areutilized to perform the task, in that the number and variety ofparameters may increase accordingly.

[0010] Additionally, many current measurement systems require that theuser perform a significant amount of programming, either in a text-basedprogramming language such as LabWindows or Visual Basic, or in agraphical programming language such as LabVIEW. It would be desirablefor a user to be able to more easily create measurement solutions withreduced programming requirements.

[0011] Therefore, it would be desirable to provide new systems andmethods for specifying and performing measurement tasks.

SUMMARY OF THE INVENTION

[0012] A system and method are presented for creating a graphicalprogram that performs a task, such as a measurement task. In oneembodiment, the method includes displaying a node in a graphicalprogram, configuring the node to receive a measurement taskspecification, and executing the graphical program. The node may be aprimitive node provided by a graphical programming developmentenvironment for inclusion in the graphical program. Configuring the nodeto receive the measurement task specification may include connecting aninput terminal of the node to an output terminal of another node in thegraphical program. In one embodiment, the other node is a measurementtask specification node which represents a generated measurement taskspecification characterizing or specifying a desired measurement task.In another embodiment, the other node may be a configuration node whichoperates to configure a measurement task specification for input to thenode. The configuration node may operate in conjunction with zero ormore other configuration nodes to generate the measurement taskspecification during execution of the graphical program. In other words,one or more configuration nodes may incrementally add configurationinformation to the measurement task specification, thereby building acomplete measurement task specification for input to the node.

[0013] The measurement task may include one or more measurements and/orone or more signal generations. When the measurement task includes ameasurement, the node may be a read node. When the measurement taskincludes a signal generation, the node may be a write node. In oneembodiment, the node may be a start node, also referred to as a playnode, which is operable to be connected to a read node for performing ameasurement, or a write node for performing a signal generation. The GUImay also display a stop node in the graphical program, where the stopnode is also connected to the read or write node. The stop node may beoperable to terminate the measurement task, i.e., the measurement (read)or signal generation (write).

[0014] In executing the graphical program, the node may receive themeasurement task specification as input. The node may then invoke anexpert system to analyze the measurement task specification and generatea run-time specification for the measurement task in response to theanalyzing. In one embodiment, the expert system may validate themeasurement task specification prior to generating the run-timespecification. The node may then invoke a run-time builder to analyzethe run-time specification and generate a run-time based on the run-timespecification, where the runtime may be executable to perform themeasurement task. Finally, the node may invoke execution of the run-timeto perform the measurement task. In one embodiment, the runtime buildermay configure one or more measurement devices according to the run-timespecification, where the run-time executes to perform the measurementtask using the configured one or more measurement devices.

[0015] In one embodiment, a measurement task specifier may be used togenerate the measurement task specification. For example, themeasurement task specifier may display a graphical user interface (GUI)for specifying the measurement task. The GUI may receive user inputindicating values for a plurality of parameters characterizing themeasurement task, where the values for the plurality of parameters areuseable in generating the measurement task specification. Themeasurement task specifier may then generate the measurement taskspecification based on the indicated parameter values. In oneembodiment, the measurement task specification may include configurationinformation for one or more measurement devices, where, after beingconfigured with the configuration information, the one or moremeasurement devices may be operable to perform the measurement task.

[0016] In one embodiment, the task may be a repetitive task, where thenode may invoke two or more iteration cycles of the program to performthe task. In some applications there may be special conditions relatedto the initial iteration cycle of the repetitive task. In this case, thenode may be further operable to perform one or more operations prior toor during a first iteration cycle of the program. For example, certainvariables, data structures, programs, or devices may need to beinitialized before the task is performed. To accommodate these specialconditions, the node may perform one or more operations prior to orduring a first iteration cycle of the program. In yet anotherembodiment, the node may perform one or more operations during the firstn iteration cycles of the program, where the value of n may be specifiedby the user. For example, in an application where the task involvescomputing a moving average of sample values, the moving average windowmay be n data points long, and thus may not be “filled” until niteration cycles have been performed. The node may be operable toperform special operations to accommodate this condition for the first niteration cycles of the program.

[0017] As mentioned above, the graphical program may also include a stopnode which operates to terminate the repetitive task. In other words,the stop node may operate to terminate the specified task, e.g., dataacquisition by the measurement device, upon fulfillment of stoppingconditions. In another embodiment, where the node includes impliedlooping functionality, the node itself may function as the stop node.Where the node invokes two or more iteration cycles of the program toperform the task, the node may be further operable to perform one ormore operations during or after a final iteration cycle of the program.For example, certain “clean-up” operations may need to be performed justbefore or during task termination, such as de-allocation of memory fordata structures used in performing the task, among others. For anotherexample, in the application described above where the task involvescomputing a moving average of sample values, it may be the case thatwhereas the averaging algorithm operates on 20 data points or samples ata time, in the last cycle there may only, say, six data pointsavailable. Thus, a boundary condition for the algorithm may exist whichmust be accommodated for the algorithm to complete successfully.Therefore, in another embodiment, the node may be operable to performone or more operations during or after a final iteration cycle of theprogram.

[0018] When the task is a repetitive task, the node may include animplied processing loop, i.e., “while loop” or “for loop” functionalitymay be incorporated in the node. Thus, a read node or write node mayoperate to perform looping functionality to perform iterative tasks. Inone embodiment, configuring the node to perform the repetitive task mayinclude displaying a different node or icon, e.g., a loopingconfiguration node, in the graphical program which represents arepetitive task parameter, and connecting the node to the different nodeto indicate that the node is to execute repetitively in accordance withthe repetitive task parameter. Said another way, rather than displayingthe node in a loop structure in the graphical program, the node may beconnected to another node in the graphical program which specifieslooping functionality. The node may then be operable to performiterative tasks. In one embodiment, the node may receive loopingspecifications from the different node, but implement the loopingfunctionality itself. In another embodiment, the different node, e.g.,the looping configuration node, may execute to perform the loopingfunctionality for the iterative task.

[0019] In one embodiment, the graphical program may be generatedprogrammatically. The programmatically generated program may be agraphical program, such as a LabVIEW graphical program, or a text-basedprogram, e.g., a C program. For example, the GUI may receive user inputindicating or requesting programmatic generation of the graphicalprogram, and the graphical program may then be generatedprogrammatically in response to the user input. The measurement taskspecifier may then generate the program based on the parameter valuesspecified for the measurement task. In another embodiment, themeasurement task specifier may generate the program based on themeasurement task specification. If the program is a graphical program,the GUI may display a block diagram of the generated program, forexample, in a program panel.

[0020] In one embodiment, the graphical program, e.g., the node, may beoperable to receive user input selecting the node, and to display a moredetailed graphical program representing operations of the node. Forexample, where the node includes looping operations as described above,double-clicking on the node may result in displaying a loop structure inthe graphical program, e.g., around the node.

BRIEF DESCRIPTION OF THE DRAWINGS

[0021] A better understanding of the present invention may be obtainedwhen the following detailed description of the preferred embodiment isconsidered in conjunction with the following drawings, in which:

[0022]FIG. 1 illustrates an exemplary computer system suitable forimplementing various embodiments of the present invention;

[0023]FIG. 2 illustrates the computer system of FIG. 1 coupled to aserver across a network, according to one embodiment;

[0024]FIGS. 3A and 3B illustrate representative instrumentation andprocess control systems, including various I/O interface options;

[0025]FIG. 4 is a block diagram of the computer system of FIGS. 1, 2, 3Aand 3B;

[0026]FIG. 5 illustrates one embodiment of a software architecture of ameasurement system;

[0027]FIG. 6 illustrates measurement driver program components,according to one embodiment;

[0028]FIG. 7 flowcharts a measurement process, according to oneembodiment;

[0029]FIG. 8 illustrates a high level architecture of the system,according to one embodiment;

[0030]FIG. 9 illustrates a measurement task specification, according toone embodiment;

[0031]FIG. 10 illustrates a method for using a graphical program node togenerate a program for performing a specified task, according to oneembodiment;

[0032] FIGS. 11A-11E illustrate various embodiments of a graphicalprogram for performing a voltage measurement;

[0033]FIG. 12 illustrates a graphical program for performing buffered AIand DI with a shared clock and trigger, according to one embodiment ofthe present invention;

[0034] FIGS. 13A-13F illustrate various embodiments of a graphicalprogram node for performing repetitive tasks and/or generating a programto perform repetitive tasks;

[0035]FIG. 14 flowcharts one embodiment of a method for performing atask using a loop structure; and

[0036] FIGS. 15A-15G illustrate various embodiments of a graphicalprogram loop structure for performing repetitive tasks and/or generatinga program to perform repetitive tasks.

[0037] While the invention is susceptible to various modifications andalternative forms, specific embodiments thereof are shown by way ofexample in the drawings and will herein be described in detail. Itshould be understood, however, that the drawings and detaileddescription thereto are not intended to limit the invention to theparticular form disclosed, but on the contrary, the intention is tocover all modifications, equivalents and alternatives falling within thespirit and scope of the present invention as defined by the appendedclaims.

DETAILED DESCRIPTION OF SEVERAL EMBODIMENTS

[0038] Incorporation by Reference

[0039] U.S. application Ser. No. ______ titled “Graphical ProgramLooping Structure That Performs An Auxiliary Function” filed ______,2002 and whose inventors are , is hereby incorporated by reference asthough fully and completely set forth herein.

[0040] U.S. application Ser. No. 10/128,843 titled “Measurement SystemGraphical User Interface for Easily Creating Measurement Applications”filed Apr. 24, 2002, and whose inventors are Brian Johnson, John Breyer,and Joe Savage, is hereby incorporated by reference as though fully andcompletely set forth herein.

[0041] U.S. application Ser. No. 10/008,792 titled “Measurement SystemSoftware Architecture for Easily Creating High-Performance MeasurementApplications” filed Nov. 13, 2001, and whose inventors are GeoffreySchmit, Brent Schwan, Jonathan Brumley, Thomas A. Makowski, andChristopher T. Bartz, is hereby incorporated by reference as thoughfully and completely set forth herein.

[0042] U.S. patent application Ser. No. 10/010,829 titled “MeasurementsExpert System and Method For Generating High-Performance MeasurementsSoftware Drivers” filed Nov. 13, 2001, and whose inventors are GeoffreySchmit, Jonathan Brumley, Brent Schwan and Jack Levy, is herebyincorporated by reference as though fully and completely set forthherein.

[0043] U.S. patent application Ser. No. 10/010,826 titled “A System ofMeasurements Experts and Method for Generating High-PerformanceMeasurements Software Drivers” filed Nov. 13, 2001, and whose inventorsare Geoffrey Schmit, Jonathan Brumley, Brent Schwan and Jack Levy, ishereby incorporated by reference as though fully and completely setforth herein.

[0044] U.S. Provisional Application Serial No. 60/301,785 titled“Measurement System Software Architecture for Easily CreatingHigh-Performance Measurement Applications” filed Jun. 29, 2001, andwhose inventors are Geoffrey Schmit, Brent Schwan, Jonathan Brumley,Thomas A. Makowski, and Christopher T. Bartz, is hereby incorporated byreference as though fully and completely set forth herein.

[0045]FIG. 1—Computer System

[0046]FIG. 1 illustrates a computer system 102 operable to executevarious embodiments of the present invention. The computer system 102may be any type of computer system, including a personal computersystem, mainframe computer system, workstation, network appliance,Internet appliance, personal digital assistant (PDA), television systemor other device. In general, the term “computer system” may be broadlydefined to encompass any device having at least one processor thatexecutes instructions from a memory medium.

[0047] As shown in FIG. 1, the computer system 102 may include a displaydevice operable to display operations associated with the methodsdescribed herein. For example, the display device may be operable todisplay a graphical user interface which allows a user to specify ordescribe a measurement task. The graphical user interface may compriseany type of graphical user interface, e.g., depending on the computingplatform. As shown, the computer system 102 may include one or moreinput devices, such as a keyboard, mouse, etc. The computer system 102may include one or more processors, e.g., CPUs and/or programmablehardware elements, which may be operable to execute program instructionsaccording to various embodiments of the present invention.

[0048] The computer system 102 may include a memory medium(s) on whichone or more computer programs or software components according to oneembodiment of the present invention may be stored. For example, thememory medium may store one or more software programs which areexecutable to perform the methods described herein. Also, the memorymedium may store a programming development environment application usedto create and/or execute measurement software programs. The memorymedium may also store operating system software, as well as othersoftware for operation of the computer system.

[0049] The term “memory medium” is intended to include various types ofmemory or storage, including an installation medium, e.g., a CD-ROM,floppy disks, or tape device; a computer system memory or random accessmemory such as DRAM, SRAM, EDO RAM, Rambus RAM, etc.; or a non-volatilememory such as a magnetic media, e.g., a hard drive, or optical storage.The memory medium may comprise other types of memory or storage as well,or combinations thereof. In addition, the memory medium may be locatedin a first computer in which the programs are executed, or may belocated in a second different computer which connects to the firstcomputer over a network, such as the Internet. In the latter instance,the second computer may provide program instructions to the firstcomputer for execution.

[0050] In addition, the memory medium may be located in a firstcomputer, e.g., computer system 102, or may be located in a seconddifferent computer which connects to the first computer over a network,such as the Internet, as described below with reference to FIG. 2. Inthe latter instance, the second computer may provide programinstructions to the first computer for execution.

[0051]FIG. 2—A Network System

[0052]FIG. 2 illustrates a simplified and exemplary network system thatoperates according to various embodiments of the present invention. Inthe system shown in FIG. 2 the computer system 102 of FIG. 1 is coupledto a second computer 106, such as a server computer system 106, over anetwork 204, such as the Internet, or a computer bus. Thus, FIG. 2illustrates an exemplary distributed system which may be suitable forimplementing the methods described herein. The computer systems 102 and106 may each be any of various types as desired, as described above.Also, the network 204 can also be any of various types, including a LAN(local area network), WAN (wide area network), the Internet, or anIntranet, among others. The transmission medium coupling the systems mayinclude any wired or wireless media, as are well known in the art. Thus,in one embodiment, the host computer 102 and the server computer 106 maycomprise a distributed system.

[0053] As used herein, the term “distributed system” is intended toinclude a system comprising two or more interconnected or coupleddevices, i.e., two or more devices that are coupled together in somefashion. The two or more devices may be coupled together via wired orwireless means. Wired means may include a network, such as a local areanetwork (LAN) and/or a wide area network (WAN), such as the Internet, acomputer bus, a serial or parallel bus, or other wired communicationmethods. Example local area networks include Ethernet networks, TokenRing networks, and various industrial communication networks such asfieldbus, DeviceNet, and CAN (Controller Area Network) networks. Exampleparallel buses include the PCI bus, PXI bus, GPIB, and VXI bus, amongothers. Example serial buses include USB (Universal Serial Bus), IEEE1394, RS-242, and RS-485, among others. Wireless means may includewireless protocols such as IEEE 802.11 (wireless Ethernet), Bluetooth,and other types of wireless communication.

[0054] In one embodiment, the server 106 may store programs,applications, or data which may be accessed or retrieved by the hostcomputer system 102. Thus, the server 103 may store measurement taskspecification software or information, for example, in a database orlibrary. The computer system 102 may access the server 106 to retrievedata or execute software to implement various embodiments of the systemand method described herein.

[0055] FIGS. 3A and 3B—Instrumentation and Industrial Automation Systems

[0056]FIGS. 3A and 3B illustrate exemplary measurement and automationsystems. As used herein, the term “measurement system” is intended toinclude the types of measurement systems and automation systems shown inFIGS. 3A and 3B, as well as other types of systems. The measurementsystem shown in FIGS. 3A and 3B may include software programs accordingto one embodiment of the present invention. These programs may of coursebe stored in or used by other types of systems as desired. In accordancewith one embodiment of the present invention, the present system andmethod includes a novel software architecture and novel softwareprograms for allowing users to more easily create measurement andautomation tasks (collectively referred to as “measurement tasks”),verify functionality, and easily create application code to implementdesired tasks.

[0057] As used herein, the term “measurement system” is intended toinclude an instrumentation system such as that shown in FIG. 3A, anindustrial automation system such as that shown in FIG. 3B, or amodeling or simulation system involved with the design, validation ortesting of a product involving “real world I/O”, i.e., the acquisitionor generation of data to/from a model or simulation of a device orproduct being designed, validated or tested, such as hardware-in-theloop validation. The term “measurement” may include instrumentationmeasurement, data acquisitions, automation, control, and simulation.

[0058]FIG. 3A illustrates an exemplary instrumentation control system100. The system 100 may comprise a host computer 102 which connects toone or more devices or instruments. The host computer 102 may comprise aCPU, a display, memory, and one or more input devices such as a mouse orkeyboard, as shown. The host computer 102 connects through the one ormore instruments to analyze, measure, or control a unit under test (UUT)or process 150.

[0059] The host computer 102 may execute a program which interacts withor controls the one or more instruments. The one or more instruments mayinclude a GPIB instrument 112 and associated GPIB interface card 122, adata acquisition board 114 and associated signal conditioning circuitry124, a VXI instrument 116, a PXI instrument 118, a video device orcamera 132 and associated image acquisition card 134, a motion controldevice 136 and associated motion control interface card 138, and/or oneor more computer based instrument cards 142, among other types ofdevices. Note that the computer based instrument card 142 may be a boardor card with one or more FPGAs, one or more CPUs and memory, or variouscombinations of the two.

[0060] The GPIB instrument 112 may be coupled to the computer 102 viathe GPIB interface card 122 provided by the computer 102. In a similarmanner, the video device 132 may be coupled to the computer 102 via theimage acquisition card 134, and the motion control device 136 may becoupled to the computer 102 through the motion control interface card138. The data acquisition board 114 may be coupled to the computer 102,and may interface through signal conditioning circuitry 124 to the UUT.The signal conditioning circuitry 124 may comprise an SCXI (SignalConditioning extensions for Instrumentation) chassis comprising one ormore SCXI modules 126.

[0061] The GPIB card 122, the image acquisition card 134, the motioncontrol interface card 138, and the DAQ card 114 are typically pluggedin to an I/O slot in the computer 102, such as a PCI bus slot, a PC Cardslot, or an ISA, EISA or MicroChannel bus slot provided by the computer102. However, these cards 122, 134, 138 and 114 are shown external tocomputer 102 for illustrative purposes. These cards 122, 134, 138, 114may also connected to the computer 102 through a USB (Universal SerialBus), IEEE 1394 or 1394.2 bus provided by the computer 102.

[0062] The VXI chassis or instrument 116 may be coupled to the computer102 via a VXI bus, MXI bus, or other serial or parallel bus provided bythe computer 102. The computer 102 may include VXI interface logic, suchas a VXI, MXI or GPIB interface card (not shown), which interfaces tothe VXI chassis 116. The PXI instrument may be coupled to the computer102 through the computer's PXI bus. The PXI chassis may be coupled tothe computer 102 via a MXI-3 bus.

[0063] A serial instrument (not shown) may also be coupled to thecomputer 102 through a serial port, such as an RS-232 port, USB(Universal Serial bus) or IEEE 1394 or 1394.2 bus, provided by thecomputer 102.

[0064] In typical instrumentation control systems an instrument of eachinterface type may not be present, and in fact many systems may onlyhave one or more instruments of a single interface type, such as onlyGPIB instruments. The instruments are coupled to the unit under test(UUT) or process 150, or are coupled to receive field signals, typicallygenerated by transducers. The system 100 may be used in a dataacquisition and control application, in a test and measurementapplication, a process control application, a man-machine interfaceapplication, or a simulation application.

[0065]FIG. 3B illustrates an exemplary industrial automation system 160.The industrial automation system 160 may be similar to theinstrumentation or test and measurement system 100 shown in FIG. 3A.Elements which are similar or identical to elements in FIG. 3A have thesame reference numerals for convenience. The system 160 comprises acomputer 102 which connects to one or more devices or instruments. Thecomputer 102 comprises a CPU, a display screen, memory, and one or moreinput devices such as a mouse or keyboard as shown. The computer 102connects through the one or more devices to a process or device 150 toperform an automation function, such as NMI (Man Machine Interface),SCADA (Supervisory Control and Data Acquisition), portable ordistributed data acquisition, process control, advanced analysis, orother control. In FIG. 3B, the computer 102 may execute a program thatis involved with the automation function performed by the automationsystem 160.

[0066] The one or more devices may include a data acquisition board 114and associated signal conditioning circuitry 124, a PXI instrument 118,a video device 132 and associated image acquisition card 134, a motioncontrol device 136 and associated motion control interface card 138, aFieldBus device 170 and associated FieldBus interface card 172, a PLC(Programmable Logic Controller) 176, a serial instrument 182 andassociated serial interface card 184, or a distributed data acquisitionsystem, such as the FieldPoint system available from NationalInstruments, among other types of devices.

[0067] The DAQ card 114, the PXI chassis 118, the video device 132 andimage acquisition card 134, and the motion control device 136 and motioncontrol interface card 138 may be coupled to the computer 102 asdescribed above. The serial instrument 182 may be coupled to thecomputer 102 through a serial interface card 184, or through a serialport, such as an RS-232 port, provided by the computer 102. The PLC 176may couple to the computer 102 through a serial port, Ethernet port, ora proprietary interface. The FieldBus interface card 172 may becomprised in the computer 102 and interfaces through a FieldBus networkto one or more FieldBus devices. Each of the DAQ card 114, the serialcard 184, the FieldBus card 172, the image acquisition card 134, and themotion control card 138 are typically plugged in to an I/O slot in thecomputer 102 as described above. However, these cards 114, 184, 172,134, and 138 are shown external to computer 102 for illustrativepurposes. In typical industrial automation systems a device will not bepresent of each interface type, and in fact many systems may only haveone or more devices of a single interface type, such as only PLCs. Thedevices are coupled to the device or process 150.

[0068] Referring again to FIGS. 3A and 3B, the computer system 102and/or one or more of the instruments or devices may include a memorymedium (or memory mediums) on which software according to the presentinvention may be stored. The memory medium may store a measurement taskspecifier, and optionally, an expert system, a plurality of experts, arun-time builder, and/or a plurality of measurement primitives.Additionally, the memory medium(s) may store various products producedby or with these software components, such as a measurement taskspecification, a run-time specification, and/or a run-time, all of whichare described in more detail below. The memory medium(s) may also storeconfiguration information for one or more of the above softwareprograms.

[0069] In one embodiment, the software programs and softwarearchitecture as described herein may be designed for measurementsystems, including data acquisition/generation, analysis, and/ordisplay; automation systems; simulation systems; systems forcontrolling, modeling, or simulating instrumentation or industrialautomation hardware; and systems for controlling, modeling or simulatingsystems or devices being designed, prototyped, validated or tested.However, it is noted that the present invention can be used for aplethora of applications and is not limited to instrumentation orindustrial automation applications. In other words, FIGS. 3A and 3B areexemplary only, and the software programs and software architecture maybe used for any of various purposes and may be stored in and execute onany of various types of systems to perform any of various applications.

[0070]FIG. 4—Computer System Block Diagram

[0071]FIG. 4 is an exemplary block diagram of the computer systemillustrated in FIGS. 3A and 3B. It is noted that any type of computersystem configuration or architecture can be used in conjunction with thesystem and method described herein, as desired, and FIG. 4 illustrates arepresentative PC embodiment. It is also noted that the computer systemmay be a general purpose computer system such as illustrated in FIGS. 3Aand 3B, a computer implemented on a VXI card installed in a VXI chassis,a computer implemented on a PXI card installed in a PXI chassis, orother types of embodiments. The elements of a computer not necessary tounderstand the present invention have been omitted for simplicity.

[0072] The computer 102 includes at least one central processing unit orCPU 160 which is coupled to a processor or host bus 162. The CPU 160 maybe any of various types, including a x86 processor, e.g., a Pentiumclass; a PowerPC processor; a CPU from the SPARC family of RISCprocessors; as well as others. Main memory 166 is coupled to the hostbus 162 by means of memory controller 164. The main memory 166 may storeone or more computer programs or libraries according to one embodimentof the present invention. The main memory 166 also stores operatingsystem software as well as the software for operation of the computersystem, as well known to those skilled in the art.

[0073] The host bus 162 is coupled to an expansion or input/output bus170 by means of a bus controller 168 or bus bridge logic. The expansionbus 170 is preferably the PCI (Peripheral Component Interconnect)expansion bus, although other bus types can be used. The expansion bus170 includes slots for various devices such as the data acquisitionboard 114 (of FIG. 3A), a GPIB interface card 122 which provides a GPIBbus interface to the GPIB instrument 112 (of FIG. 3A), and areconfigurable instrument 120. Note that as used herein, the term“reconfigurable instrument” refers to an instrument with one or more of:

[0074] 1) a processor and memory which is capable of being configured bya user or software program; and/or

[0075] 2) reconfigurable logic, such as an FPGA (Field Programmable GateArray).

[0076] For more information on a reconfigurable instrument whichincludes an embedded processor and embedded memory, please see U.S. Pat.No. 6,173,438 which is hereby incorporated by reference in its entiretyas though fully and completely set forth herein. For more information ona reconfigurable instrument which includes reconfigurable hardware,e.g., an FPGA, please see U.S. Pat. No. 6,219,628 which is herebyincorporated by reference in its entirety as though fully and completelyset forth herein. The computer 102 may further comprise a video displaysubsystem 180 and hard drive 182 coupled to the expansion bus 170.

[0077]FIG. 5—Creating a Measurement Solution

[0078]FIG. 5 illustrates one embodiment of a software architecture for asystem such as a measurement system. As shown, the system may includeone or more application programs 202. The application programs aretypically developed by a user to accomplish a certain task or achieve acertain result. Thus, the application program is typically a usercreated or developed program to solve a desired problem or accomplish adesired result for the user. It is noted that in addition touser-developed applications, programmatically generated applicationprograms are also contemplated. The application program 202 may bedeveloped in any of various development environments. For example, theapplication program may be an application developed in the LabVIEWgraphical programming environment of National Instruments Corporation.The application program 202 may also be developed in other applications,such as National Instruments Measurement Studio, Visual Basic, VisualC++, Delphi, or other programming development environments. Thus, theapplication program may be developed in graphical programmingenvironments such as LabVIEW, or a text-based programming environmentsuch as Measurement Studio or Visual Basic. The application program 202may thus comprise the customer's entire measurement system, and mayinclude many more features and functions in addition to managing theparticular measurement task specification and run-time generation, suchas data analysis, report generation, or other higher-level functions ofthe measurement system.

[0079] As shown, the application 202 communicates with a measurementdriver 212. The measurement driver 212 may include a measurement driverapplication programming interface (API) 214. As shown, the applicationprogram 202A or 202B interfaces with the measurement driver API 214 inorder to access capabilities of the measurement driver 212. In thismeasurement example, the software architecture may also includeinterchangeable virtual instrument (IVI) drivers 222 wherein theapplication program 202B may interface through IVI drivers 222, whichinterface with the measurement driver API 214, to interface with themeasurement driver 212.

[0080] The measurement driver 212 interfaces to the one or more variousmeasurement devices 230 comprised in this system. The measurementdevices 230 may comprise any of the various devices discussed above withrespect to FIG. 5A or 3B and may comprise other devices not shown inFIGS. 3A and 3B as desired. In one embodiment, at least one of the oneor more measurement devices comprises a hardware measurement device. Inanother embodiment, at least one of the one or more measurement devicescomprises a virtual measurement device.

[0081] In one embodiment, the present invention provides an improvedsystem and method for creating application programs, such as applicationprograms 202A and 202B. The measurement driver 212 preferably includesvarious software that may allow creation of an application program 202Aor 202B using a high-level interface and requiring reduced user effortand coding.

[0082]FIG. 6—Measurement Driver Program Components

[0083]FIG. 6 illustrates various software components or programs 400comprised in the measurement driver program 212. As shown, themeasurement driver program 212 may include a measurement task specifier730, and optionally, an expert system 750 with one or more experts 406,a run-time builder 780, and/or various measurement primitives 408. Themeasurement driver 212 may include other software components as well.

[0084] As FIG. 6 also illustrates, various of the measurement drivercomponents may be operable to generate respective products 450 which maybe useable by other measurement driver components, by other softwareprograms or systems, or by a user. More specifically, as shown in FIG.6, in one embodiment, the measurement task specifier 730 may be operableto generate a measurement task specification 740, also referred to as atask specification. It is noted that the specified measurement task mayinclude both measurement (i.e., inputs) and generation (i.e., outputs)type tasks. For example, in a testing application, the measurement taskmay include generating one or more signals for excitation or stimulationof an UUT, as well as measuring the response of the UUT to the generatedsignal(s). The generated signal(s) may also include signals fortriggering, synchronization, communication, control, or other functions,as desired. Examples of generated signals include sine wave, squarewave, gaussian pulse, and sawtooth waveforms, among others.

[0085] In one embodiment, the measurement task specification 740 maycomprise software objects or data structures, such as C++ objects, whichmay specify the measurement task. In one embodiment, the measurementtask specifier 730 may be a measurement task wizard, i.e., a softwareprogram which leads the user through a measurement task specificationprocess to create the measurement task specification 740. In anotherembodiment, the measurement task specifier 730 may take the form of ameasurement task configuration tool, which is a software programinvocable by the user under a development environment, such as theNational Instruments LabVIEW environment or Measurement Studioprogramming development environment. In yet another embodiment, themeasurement task specifier 730 may simply be an API through which theuser makes calls to generate the task specification. Thus, in variousembodiments, the measurement task specifier 730 may generate themeasurement task specification 740 in response to user input.

[0086] As shown, an expert system 750 may use the measurement taskspecification 740 to generate a run-time specification 770. The expertsystem 750 may include a plurality of experts. The expert system 750 mayinclude one or more experts for each of the measurement device typesshown in FIGS. 3A and 3B, in addition to various other experts,including routing experts, streaming experts, and synchronizationexperts, among others. In one embodiment, the expert system 750 may alsobe utilized by the measurement task specifier 730 in generating themeasurement task specification 740. For example, the measurement taskspecifier 730 may invoke the expert system 750 to validate themeasurement task specification 740. In other words, the expert system750 may analyze the measurement task specification 740 to verify thatthe specified task is implementable with available software and/orhardware, and/or that the measurement task specification 740 isinternally and/or externally consistent. For example, the expert system750 may detect that two components or sub-tasks specified in themeasurement task specification 740 are mutually incompatible, and reportan error accordingly.

[0087] In one embodiment, the run-time specification 770 may similarlycomprise software objects or data structures, such as C++ objects, whichmay specify the run-time parameters for software and/or hardware used toimplement the specified measurement task. The run-time specification 770may comprise parameter specifications for one or more measurementprimitives 408 which correspond to rudimentary measurement tasks oroperations. Said another way, the run-time specification 770 maycomprise a collection of primitive settings, each of which may comprisea detailed and unambiguous “recipe” for a primitive. For example,primitive settings for a digitizer, such as a National InstrumentsE-Series digitizer, may include: Dither (Yes, No), Polarity (Bipolar,Uni-polar), Gain, Mode (Calibration, Differential, Non-ReferencedSingle-Ended, Referenced Single-Ended, Auxillary, Ghost), GenerateTrigger (Yes, No), and Last Channel (Yes, No).

[0088] The run-time specification 770 may in turn be interpreted by therun-time builder 780 to generate a run-time 790, which may be executableto perform the specified measurement task. More details of the operationof the measurement driver program are presented below with reference toFIG. 7.

[0089]FIG. 7—Method For Performing A Measurement Task

[0090]FIG. 7 is a flowchart diagram illustrating one embodiment of theoperation of the measurement system, the method being used to configureinstalled measurement hardware devices and to specify and create ameasurement task or application program to operate the measurementsystem. In one embodiment, the measurement task may comprise a pluralityof measurement sub-tasks. In another embodiment, the measurement taskmay comprise a complex measurement operation using a plurality ofmeasurement devices. It is noted that the flowchart of FIG. 7 isexemplary only. Further, various steps in the flowchart of FIG. 7 mayoccur concurrently or in different order than that shown, or may not beperformed, as desired. Also, various steps may be added as desired.

[0091] As shown, in step 502 a user may optionally install measurementhardware within the system. This may comprise connecting a measurementdevice to the computer system or installing a measurement card or boardwithin a slot of the computer system. This may further compriseinstalling a measurement card or board in a slot of a chassis, such as aPXI chassis, which itself is coupled to the computer system and/or whichmay contain a computer system comprised on a card within the chassis. Inone embodiment, the measurement hardware may comprise a “reconfigurablemeasurement device” which may be operable to be reconfigured “on thefly” during a measurement task or operation. For example, thereconfigurable measurement device may include a processor and memory oran FPGA that may be reconfigured with different measurement programs ortasks.

[0092] In step 504 the computer system and/or the user may optionallyconfigure the measurement hardware device(s). This may involve operationof standard Plug & Play software to recognize the measurement device andselect setting or parameters for the device. It should be noted that inmany instances, the user may not be required to perform 502 and/or 504before generating the measurement task. In other words, the measurementhardware may already be installed and configured and the user mayproceed with the configuration and specification of the measurement taskin step 506. In another embodiment, “stub” interfaces may be provided,e.g., in software, which emulate the presence of measurement devices,allowing the user to design or specify the measurement task withoutactually installing the necessary hardware and/or software.

[0093] In step 506 the user may invoke the measurement task specifier730 to configure a desired task in the measurement driver 212, therebyproducing a measurement task specification 740. In the preferredembodiment, the measurement task specifier 730 includes an interactiveGraphical User Interface (GUI) configuration tool which enables the userto easily and simply configure a desired measurement task. This mayinvolve selecting various parameters of the task such as the type ofmeasurement being performed, e.g., voltage, current, etc., and othermeasurement settings.

[0094] In one embodiment, once the task has been specified, the user mayadd specification objects, modules, or code, specifying start,read/write, and/or cleanup operations to the task specification. In oneembodiment, once the task has been specified, the user may request thetask specifier 730 to generate code. The task specifier may thenprogrammatically generate code specifying start, read/write, and/orcleanup operations, among others. In various embodiments, this generatedcode may comprise one or more icons in a LabVIEW graphical program(i.e., VIs), as described in more detail below, and/or function calls ina text-based program including one or more of C code, C++ code, C# code,Java code, Visual Basic code, or any other form of computer programcode, which may specify support operations needed to implement thespecified measurement task. In one embodiment, the generated code maycomprise icons representing some or all of the specified measurementtask operations, including clocking and trigger operations, amongothers. In one embodiment, the task specifier 730 may generate the iconsand connect them together appropriately. In another embodiment, the taskspecifier 730 may generate the icons, but the user may be required tolink the icons appropriately. Thus, in one embodiment, the method mayinclude generating a measurement task diagram in response to user inputspecifying the measurement task. In one embodiment, the measurement taskdiagram may comprise a graphical program, such as a LabVIEW graphicalprogram.

[0095] It should be noted that a node for use in a graphical programtypically includes a graphical icon which may be displayed in thegraphical program to visually represent the node in the graphicalprogram. A node for use in a graphical program may also includeunderlying program instructions and/or data structures which perform thefunctionality of the node. When the present application states that anode performs a function, it is understood that the program instructionsand/or data structures of the node actually perform this function. Thus,the graphical icon that visually represents the node represents thefunction, and the underlying program instructions and/or data structureswhich are represented by the node graphical icon are actually performingthe function. Thus the specification and claims of the presentapplication refer generally to a node performing a function, it beingunderstood that the node includes or represents underlying programinstructions and/or data structures which are executed by a processor(or programmable hardware element) to perform the function.

[0096] In another embodiment, the user may specify the task manually.For example, the user may use a graphical programming developmentenvironment such as LabVIEW to place one or more icons or nodes on thedisplay and connect them in a desired way to accomplish the desiredresult. In one embodiment, the user may select a small number offunction icons or nodes, such as a measurement read node or measurementwrite node, to accomplish the configured measurement task. As anotherexample, the user may use the Measurement Studio programming developmentenvironment from National Instruments Corporation (e.g., LabWindows/CVI)to create a text-based program to accomplish the measurement task. Thistext-based program would typically comprise very few lines of code.Thus, complex measurement procedures may be encapsulated and representedby simple icons or function calls, allowing the user to rapidly andeasily create measurement “programs” to implement or carry out complexmeasurement operations.

[0097] In one embodiment, the measurement task specifier 730 maycomprise a measurement task wizard. In other words, the measurement taskspecifier 730 may be a software program which leads the user through ameasurement task specification process, thereby generating themeasurement task specification 740. In another embodiment, themeasurement task specifier 730 may comprise a measurement taskconfiguration tool. The measurement task configuration tool may be asoftware program invocable by the user within a development environment,such as National Instruments' LabVIEW environment, Measurement Studioprogramming development environment, or any other developmentenvironment. For example, the user may specify or configure ameasurement task by placing or “dropping” nodes or icons on a graphicaldiagram and connecting the nodes via virtual “wires” to generate agraphical diagram or model of the measurement task. The graphicaldevelopment environment program (e.g., LabVIEW) may generate softwareobjects or data structures corresponding to the components of thegraphical diagram which specify the measurement task. These datastructures may comprise the measurement task specification 740. In oneembodiment, at this stage the measurement task specification 740 is notexecutable per se, but provides information which may be used by othercomponents of the system to generate a measurement application suitableto carry out the measurement task, i.e., to implement the specifiedmeasurement operation.

[0098] In another embodiment, the measurement task specifier 730 may bean API through which the user makes calls to generate the taskspecification. For example, the user may make API function calls in aC++ application program to specify the various attributes or aspects ofthe desired measurement task, such as measurement type (voltage,current, pressure, etc.), timing or sampling parameters, or othermeasurement task specification information. The executed functions mayproduce corresponding data structures which contain specificationinformation for the measurement task. When the application program 202is executed, the API function calls may generate the measurement taskspecification 740, which may then be used later in the execution processto produce the run-time specification, as described below.

[0099] In step 508 an expert system comprised in the measurement drivermay operate to receive the measurement task specification 740, thenanalyze the measurement task specification 740, validate the measurementtask specification 740, and create a run-time specification 770 based onthe measurement task specification 740. The run-time specification 770preferably comprises parameter settings for one or more measurementdevices and other hardware comprised within the system, and may alsospecify software components or software programs which are to be usedduring execution of the task. In one embodiment, the run-timespecification 770 may comprise a specification of the parameters of oneor more measurement primitives, where each measurement primitivecomprises a software object and corresponding configuration settings,and where each measurement primitive is operable to implement at least aportion of the measurement task. Thus, the run-time specification 770may be useable to configure one or more measurement devices to performthe measurement task, and may be further useable to generate a run-time790 which is executable to perform the measurement task using theconfigured one or more measurement devices. The measurement driver 212may include expert system 750 comprising the plurality of experts 406where one or more experts 406 are available for each of the varioustypes of measurement tasks or sub-tasks. Thus, depending upon the typeof measurement task configured by the user in step 506, one or morecorresponding experts 406 may be invoked to create the run-timespecification. In one embodiment, multiple experts may each produce acandidate run-time specification. Thus, the measurement taskspecification 740 may be used in step 508 to ensure that the measurementtask can operate as configured by the user.

[0100] In one embodiment, one or more of the generated measurement taskspecification 740, the generated run-time specification 770, andconfiguration information for the one or more measurement devices may bestored, such as in a memory medium, e.g., a computer system's RAM orpersistent storage medium.

[0101] In one embodiment, the run-time builder 780 may analyze theselected run-time specification 770, and then reserve one or moreresources, such as hardware and/or software, according to the selectedrun-time specification 770. The run-time builder 780 may also un-reserveresources if the analysis of the selected run-time specificationindicates that previously reserved resources are no longer needed toimplement the measurement task. In another embodiment, the run-timebuilder 780 may handle abnormal process termination and/or unexpecteddevice removal.

[0102] In step 510 a run-time 790 may be created which embodies orimplements the measurement task configured in step 506 based on thegenerated (and/or selected) runtime specification 770. In oneembodiment, the run-time 790 may comprise a collection of measurementoperation primitives (or instances of measurement operation primitives)sequenced together which are executable to implement the measurementtask.

[0103] When the user (or software program) enters input to execute orrun the program, the measurement driver 212 may invoke the run-timebuilder program. The run-time builder program operates to access therun-time specification and use the parameters and data contained in therun-time specification to assist in creating the run-time at run time.In one embodiment, the run-time builder uses the run-time specificationto instantiate instances of various objects or primitives comprised inthe measurement driver 212. After the run-time builder instantiatesvarious instances of objects, the run-time builder may apply variousparameters from the run-time specification to these object instances.The run-time builder may also provide various parameters to hardwareand/or software resources or devices comprised in the system toconfigure the hardware and/or software devices in the system accordingto the run-time specification to allow these devices to be used duringexecution of the run-time 790. In other words, the run-time builder 780may configure one or more measurement devices according to the run-timespecification 770. After the run-time builder 780 has completed creatingthe run-time 790, the run-time may be executable to perform the taskspecified by the user.

[0104] After step 510 the user (or a software program) may execute therun-time 790 to perform the measurement task. In other words, therun-time execution may invoke the various configured hardware and/orsoftware components to perform the specified measurement task.

[0105] It should be noted that the above method, described in terms of ameasurement task, may also be applied to other types of tasks, as well,including, but not limited to, machine vision, scientific, engineering,financial, business, e-commerce, and medical tasks, among others.

[0106]FIG. 8—High-Level Architecture

[0107]FIG. 8 is a block diagram of a high-level architecture of a systemwherein various embodiments of the present invention may be used,according to one embodiment. As FIG. 8 shows, the primary components ofthe system may comprise system configuration tools 700, systemconfiguration 710, interactive and application programming interfaces730 which comprise one or more measurement task specifiers 730, taskspecification 740, expert system 750, run-time specification 770,run-time builder 780, and the run-time 790. FIG. 8 also shows thecommunication between the various components.

[0108]FIG. 9—Measurement Task Specification

[0109]FIG. 9 is a high-level block diagram of a measurement taskspecification 740, according to one embodiment. As mentioned above, inone embodiment, the measurement task specification may includeconfiguration information for one or more measurement devices, where,after being configured with the configuration information, the one ormore measurement devices are operable to perform the measurement task.As FIG. 9 shows, in one embodiment the measurement task specification740 may include a collection of measurement specification objects(MSOs). Measurement specification objects may comprise atomic objects inthe form of data structures or software classes which reflect theprimary concepts and collaborations of the measurements domain. In oneembodiment, an MSO may simply be a collection of one or more attributes.In other embodiments, an MSO may be a more complex structure which mayinclude additional information as well, such as, for example,information indicating relationships with other entities. The use ofthese objects may enable complex solutions to be broken down intosimpler components in a consistent way. Said another way, the MSOs maydescribe the user's measurement task in a device-independent manner, andmay also be operable to describe device-specific aspects of the task.

[0110] As shown, in one embodiment, the MSOs which compose themeasurement task specification 740 may include one or more channel MSOs746 and timing/triggering MSOs 748. The channel MSOs 746 may eachinclude one or more parameters for configuring a channel for themeasurement task. For example, channel configuration parameters includedin a channel MSO 746 may include one or more of: task name, channelname, terminals, input ranges, units, scales, and sensors, among others.The timing/triggering MSOs 748 may each include one or more parametersspecifying timing and/or triggering for the measurement task. Examplesof timing parameters include scan rate, number of samples, duration,clock type, and clock source, among others. Example triggeringparameters include trigger type, source, edge, level, window, andhysterisis, among others. Thus, each MSO may codify (via one or moreparameters) a particular aspect or component involved in performing themeasurement task.

[0111] One example of an MSO corresponds to a measurement. In oneembodiment, a ‘measurement MSO’ may comprise a phenomenon (i.e., adetectable signal), a terminal configuration, a desired resolution, aname, and one or more constraints. The particular values of these fieldsmay thus specify a particular measurement. Different measurementspecification objects may be linked together to form a measurement taskspecification.

[0112]FIG. 10—Method for Generating a Measurement Program

[0113]FIG. 10 flowcharts one embodiment of a method for performing atask, such as a measurement task, based on a task specification. Asmentioned previously, in various embodiments, some of the steps may beperformed in a different order than shown, or may be omitted. Additionalsteps may also be performed as desired.

[0114] As FIG. 10 shows, in 1002, a node may be displayed in a graphicalprogram. In one embodiment, the graphical program may be a LabVIEW blockdiagram, although other types of graphical programs are alsocontemplated. In one embodiment, the graphical program may be generatedprogrammatically. For example, user input to a GUI may be receivedrequesting programmatic generation of the graphical program. Thegraphical program may then be generated programmatically in response tothe user input requesting the generation. The node may be a primitivenode provided by a graphical programming development environment forinclusion in the graphical program.

[0115] In 1004, the node may be configured to receive a taskspecification as input. In one embodiment, configuring the node toreceive the task specification may include connecting an input terminalof the node to an output terminal of another node in the graphicalprogram. In one embodiment, the other node is a task specification nodewhich represents a generated task specification characterizing orspecifying a desired measurement task. In another embodiment, the othernode may be a configuration node which operates to configure a taskspecification for input to the node. The configuration node may operatein conjunction with zero or more other configuration nodes to generatethe task specification during execution of the graphical program. Inother words, one or more configuration nodes may incrementally addconfiguration information to the task specification, thereby building acomplete task specification for input to the node. Examples ofconfiguration nodes include, but are not limited to, a channelconfiguration node, which is operable to add channel configurationinformation to the task specification, a timing configuration node,which is operable to add timing configuration information to the taskspecification, and a triggering configuration node, which is operable toadd triggering configuration information to the task specification.

[0116] In one embodiment, a graphical user interface (GUI) forspecifying the task may be presented to a user. User input to the GUImay be received indicating values for a plurality of parameterscharacterizing the task, where the values are useable in generating thetask specification. The task specification may then be generated basedon the values for the plurality of parameters. The task specificationnode may then represent the task specification in the graphical program.

[0117] The measurement task may include one or more measurements and/orone or more signal generations. When the measurement task includes ameasurement, the node may be a read node. When the measurement taskincludes a signal generation, the node may be a write node. In oneembodiment, the node may be a start node, also referred to as a playnode, which is operable to be connected to a read node for performing ameasurement, or a write node for performing a signal generation. The GUImay also display a stop node in the graphical program, where the stopnode is also connected to the read or write node. The stop node may beoperable to terminate the measurement task, i.e., the measurement (read)or signal generation (write). Examples of several embodiments of thenode in a graphical program are presented in FIGS. 11A-13F, anddescribed below.

[0118] Once the node is configured, the graphical program may beexecuted to perform the specified task. For example, in one embodiment,the node may be executed in the graphical program. In other words,execution of the graphical program may include executing the node, asdescribed in more detail below.

[0119] In executing the graphical program, the node may receive the taskspecification as input, as indicated in 1006. In one embodiment,executing the graphical program may include the node invoking executionof a program to perform the task. For example, the node may invoke anexpert system to analyze the task specification, then generate theprogram based on results of the expert system, where the program isoperable to perform the task. The steps below present one embodiment ofa way for the node to accomplish this.

[0120] In 1008, the node may invoke the expert system to analyze thetask specification and generate a run-time specification for themeasurement task in response to the analyzing. In one embodiment, theexpert system may also validate the task specification prior togenerating the run-time specification. For further information regardingthe invocation of the expert system to generate the run-timespecification, please see U.S. patent application Ser. No. 10/008,792titled “Measurement System Software Architecture for Easily CreatingHigh-Performance Measurement Applications”, U.S. patent application Ser.No. 10/010,829 titled “Measurements Expert System and Method ForGenerating High-Performance Measurements Software Drivers”, and U.S.Patent Application No. 10/010,826 titled “A System of MeasurementsExperts and Method for Generating High-Performance Measurements SoftwareDrivers”, which were incorporated by reference above.

[0121] In 1010, after generation of the run-time specification, the nodemay invoke a runtime builder to analyze the run-time specification andgenerate a run-time based on the run-time specification, where therun-time may be executable to perform the measurement task. For furtherinformation regarding invocation and operation of the run-time builder,please see U.S. Patent Application No. 10/008,792 titled “MeasurementSystem Software Architecture for Easily Creating High-PerformanceMeasurement Applications”, which was incorporated by reference above.

[0122] Finally, as indicated in 1012, the node may invoke execution ofthe run-time to perform the specified task, e.g., the measurement task.Thus, the node invoking execution of the program to perform the task maycomprise the node invoking execution of the run-time to perform thetask. In one embodiment, the run-time builder may configure one or moremeasurement devices according to the run-time specification, where therun-time executes to perform the measurement task using the configuredone or more measurement devices.

[0123] Example Virtual Instrument Diagrams

[0124] FIGS. 11A-13F described below illustrate graphical programs orVirtual Instruments (VIs) block diagrams utilizing various embodimentsof the present invention. For illustrative purposes, VIs implemented inNational Instruments LabVIEW™ graphical development environment areshown which use a variety of measurement devices, such as NationalInstruments E-Series™ Data Acquisition (DAQ) devices, to implementvarious measurement tasks. It should be noted that these embodiments arefor illustrative purposes only, and are not intended to limit theinvention to any particular implementations or types of measurementdevices.

[0125] FIGS. 11A-11E—Graphical Programs for Performing a VoltageMeasurement

[0126] FIGS. 11A-11E are examples of graphical programs for performing avoltage measurement, according to one embodiment. Each example graphicalprogram shown uses an embodiment of the node described above. In FIG.11A, a single sample measurement is coded into a block diagram as asingle node which accepts as input the configured measurement taskspecification 740, here labeled myTask2. FIG. 11B illustrates agenerated block diagram of the same program, but with N samples (in thiscase, 100 samples) taken instead of a single sample.

[0127] It should be noted that the single node, be it a read node, as inFIGS. 11A, 11B, and 11D, or a start node, as in FIGS. 11C and 11E, mayencapsulate or encode both the conversion of the measurement taskspecification 740 into an executable run-time 790, as well as theexecution of the run-time to perform the specified task, as describedabove FIG. 10.

[0128] In other words, the graphical program may include a node which isconfigured to receive the measurement task specification as input. Uponexecution of the graphical program, the node may receive the measurementtask specification as input, invoke an expert system to analyze themeasurement task specification and generate a run-time specification forthe measurement task in response to the analyzing, as described above.The node may then invoke a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification. Finally, the node may invoke execution of the run-time toperform the measurement task. Thus, the single node may operate toconvert the measurement task specification to an executable run-time,and execute the run-time to perform the specified measurement task.

[0129]FIG. 11C illustrates a generated block diagram of the sameprogram, but configured for continuous acquisition, i.e., for continuoussampling. In this case, in addition to the read node (embedded in aloop), there are explicit nodes for starting (e.g., a play or startnode) and stopping (e.g., a stop node), respectively. In one embodiment,the start node may be or may function as the single node describedabove. In other words, the start node may receive the measurement taskspecification 740 as input, invoke the expert system 750 and run-timebuilder 780, as described above, thereby generating the run-time 790,and execute the generated run-time to perform the specified measurementtask.

[0130] As FIG. 11C shows, in this example, the start node accepts thetask as input, and is further wired to the read node through the loop.The read node is further wired to the stop node. The explicit start andstop nodes may be necessary because of the lack of starting and stoppingconditions implicit in the task specification. In other words, themeasurement task involves continuous acquisition of data untiltermination by the user. In the examples of FIGS. 11A and 11B, the startnode (i.e., play node) and the stop node may be considered to beimplicit in the read node. It is further noted that were the taskspecified to generate a signal, the read node would be replaced with awrite node. As FIG. 11C also shows, the number of samples returned bythe read node per iteration cycle (of the while loop) is here specifiedto be 100 samples. In other words, for each cycle of the while loop, theread node may return 100 samples to the system.

[0131] Note than in one embodiment, a start node (and a stop node) maybe used when the measurement task does not include continuousacquisition of data, as shown in FIG. 12, described below.

[0132]FIGS. 11D and 11E illustrate examples of graphical programs wherethe node (e.g., a read/write node, or a start node) receive the taskspecification from a configuration node.

[0133]FIG. 11D is a block diagram of a graphical program for performingthe voltage measurement task described above, where the node (a readnode) receives the task specification from a configuration node, asdescribed above with reference to FIG. 10, according to one embodiment.In other words, the graphical program may include configuration nodeswhich operate to generate the measurement task specification from theuser-supplied parameters. As FIG. 11D shows, in this embodiment, twochannels are used and 1 sample is acquired from each channel. Note theexplicit inclusion of channel, clock, and trigger configuration nodes,in addition to the read node. The leftmost node is a “create task” node,which operates to create a measurement task specification container orstructure. This container may start out “empty”, then be incrementallyfilled or built up by successive configuration nodes of the program, asshown. The top horizontal wire running through all of the nodes leadingto the read node represents the measurement task specification'sevolution or build process, and eventual input to the read node. Itshould be noted that although a create task node is included in thisexample, in other embodiments, the create task node may be omitted,i.e., the task container may be created implicitly.

[0134] Thus, in one embodiment, the single node described above whichreceives the measurement task specification may be connected or wired toa configuration node, which may in turn be wired to furtherconfiguration nodes, and which operates to configure the measurementtask specification for input to the node. This is in contrast to theprograms of FIGS. 11A-11B where the single node is wired to themeasurement task specification node which represents the alreadygenerated measurement task specification 740. Thus, the configurationnode(s) may operate to generate the measurement task specification 740for input to the single node.

[0135] As FIG. 11D also shows, the next two nodes after the create tasknode are channel configuration nodes. These two nodes may operate toconfigure two corresponding channels for the voltage measurement byapplying the channel parameters received by the task specifier 730. Inother words, the two channel nodes may add channel configurationinformation to the measurement task specification 740. The next node inthe succession is a trigger node which may add trigger configurationinformation to the specification 740. Note that in the diagram of FIG.11D, because this is a one sample measurement, no clock configurationnode is necessary. The program block diagram of FIG. 11E includes aclock configuration node just subsequent to the trigger configurationnode which may add clocking configuration information to the measurementtask specification 740. Thus, each successive configuration node may addrespective configuration information (based on user input parameterscollected or provided by the measurement task specifier 730) to themeasurement task specification 740.

[0136] Finally, the last configuration node, e.g., the triggeringconfiguration node in FIG. 11D, or the clock configuration node of FIG.11E, may be wired to the node, thereby providing the resultantmeasurement task specification 740 as input to the node. Note that thisresultant measurement task specification 740 is the same as thatgenerated by the measurement task specifier 730 and represented by themeasurement task specification node of FIGS. 11A-11C, described above.In this case, however, the specification 740 is generated “on the fly”during execution of the graphical program.

[0137] Note that in the diagram of FIG. 11D, the single node is a readnode, for performing the specified finite sampling measuring tasks(i.e., measurements with a defined number of samples). In contrast, inthe diagram of FIG. 11E, the single node is a start node rather than aread (or write) node because the measurement task is a continuousacquisition measurement which uses a loop. The start node may beconnected to a read node for performing a measurement, and/or a writenode for performing signal generation. Note than in this case, a stopnode is also included in the diagram for terminating the continuousacquisition task. Thus, the graphical program may include a stop nodeconnected to a read node and/or a write node for terminating acontinuous measurement or generation task.

[0138]FIG. 12—Buffered AI and Dedicated Sample Clock and Digital StartTrigger

[0139]FIG. 12 illustrates a VI for buffered AI with a dedicated sampleclock and digital start trigger, according to one embodiment of thepresent invention. Note the use of the start node (icon with filledtriangle) and stop node (icon with filled square) in a finite (fixednumber of samples) acquisition task. As described above, the start nodemay be operable to invoke the expert system and the run-time builder togenerate an executable run-time for performing the task.

[0140] FIGS. 13A-13F—Repetitive Operation Nodes

[0141] In one embodiment, the task may be a repetitive task, where thenode (or other graphical program element) may invoke two or moreiteration cycles of the program to perform the task. In someapplications there may be special conditions related to the initialiteration cycle of the repetitive task. For example, certain variables,data structures, programs, or devices may need to be created and/orinitialized before the task is performed. To accommodate these specialconditions, the node may be operable to perform one or more operationsprior to or during a first iteration cycle of the program. In yetanother embodiment, the node may perform one or more operations duringthe first n iteration cycles of the program, where the value of n may bespecified by the user. For example, in an application where the taskinvolves computing a moving average of sample values, the moving averagewindow may be n data points long, and thus may not be “filled” until niteration cycles have been performed. The node may be operable toperform special operations to accommodate this condition for the first niteration cycles of the program.

[0142] As mentioned above, the graphical program may also include a stopnode which operates to terminate the repetitive task. In other words,the stop node may operate to terminate the specified task, e.g., dataacquisition by the measurement device, upon fulfillment of stoppingconditions, for example, based on a timing or loop count, or user input.In another embodiment, where the node includes implied loopingfunctionality, the node itself may function as the stop node. Where thenode invokes two or more iteration cycles of the program to perform therepetitive or iterative task, the node may be further operable toperform one or more operations during or after a final iteration cycleof the program. For example, certain “clean-up” operations may need tobe performed just before or during task termination, such asde-allocation of memory for data structures used in performing the task,among others. For another example, in the application described abovewhere the task involves computing a moving average of sample values, itmay be the case that whereas the averaging algorithm operates on 20 datapoints or samples at a time, in the last cycle there may only, say, sixdata points available. Thus, a boundary condition for the algorithm mayexist which must be accommodated for the algorithm to completesuccessfully. Therefore, in one embodiment, the node may be operable toperform one or more operations during or after a final iteration cycleof the program. In yet another embodiment, the stop node may be operableto perform the one or more operations (during or after a final iterationcycle of the program), as described above.

[0143] As described above with reference to FIGS. 11A-11E, graphicalprograms for tasks which involve continuous sampling may bedistinguished from those which specify a finite number of samples by theinclusion of a while loop in the graphical program. However, in someembodiments of the present invention, the functionality of the loop maybe incorporated into a node, as described below.

[0144] FIGS. 13A-13F illustrate various embodiments of a node in agraphical program for performing repetitive functions, such ascontinuous acquisitions or signal generations, among other tasks. Morespecifically, FIGS. 13A-13F illustrate various embodiments of agraphical program node with looping functionality, i.e., the nodeincludes an implied processing loop. Although the examples shownillustrate “while loop” functionality, it should be noted that in otherembodiments, “for loop” functionality may be incorporated in the node.In other words, the various embodiments of loop functionality mayinclude executing a function or node continuously or a specified numberof times, as desired. Similarly, although the graphical programs ofFIGS. 13A-13F include a read node for performing acquisitions, in otherembodiments, the node may be a write node for signal generation, or adifferent type of node for performing other functions.

[0145] It should also be noted that the techniques described herein mayalso be applied to other types of tasks as well, including, but notlimited to, machine vision and control, scientific, engineering,financial, business, e-commerce, and medical tasks, among others.

[0146] Turning now to FIG. 13A, one embodiment of a graphical program isshown in which the node, here shown as a read node, is configured toperform a repetitive task, in this case, a data acquisition task. In oneembodiment, the task may comprise a repetitive measurement task,although any other type of repetitive task is also contemplated.

[0147] In this embodiment, configuring the node to perform therepetitive task includes displaying a different node or icon, e.g., alooping configuration node, in the graphical program which represents arepetitive task parameter, and connecting the node to the different nodeto indicate that the node is to execute repetitively in accordance withthe repetitive task parameter. Said another way, rather than displayingthe node in a loop structure in the graphical program, the node may beconnected to another node in the graphical program which specifieslooping functionality. The node may then be operable to performiterative tasks. In one embodiment, the node may receive loopingspecifications from the different node, but implement the loopingfunctionality itself. In another embodiment, the different node, e.g.,the looping configuration node, may execute to perform the loopingfunctionality for the iterative task.

[0148] As FIG. 13A shows, in this embodiment, the node specifyinglooping functionality indicates continuous acquisition, meaning that theread function (i.e., the read node) may execute continuously untilstopped by a user or other mechanism. In other words, the repetitivetask parameter indicates that the node is to execute continuously. Inthis embodiment, the loop specification or configuration node indicatesthe loop functionality with the phrase “continuous acquisition”,although in other embodiments, the loop functionality may be indicatedin other ways. For example, the node may simply display the term“continuous” to indicate continuous repetition of the function or task.In another embodiment, the repetitive task parameter may indicate thatthe node is to execute a specified number of times. For example, thelooping configuration node may indicate that the read node is to execute50 times, as indicated in FIG. 13F, described below. It should be notedthat the looping specification is distinct from the number of samplesspecification. More specifically, in a repetitive task, the number ofsamples refers to the number of samples collected by the node from thedevice per loop cycle, as illustrated in FIG. 13F.

[0149] As FIG. 13A also shows, a start node may couple to the read node.The start node may operate to receive a task specification and generatea program, e.g., a run-time, for performing the specified task, asdescribed above. The start node may also invoke execution of the programupon execution of the graphical program. Note also the inclusion of astop node in the graphical program. The stop node may serve to terminatethe task, e.g., the data acquisition process, as also described above.

[0150]FIG. 13B is similar to the graphical program of FIG. 13A, butrather than using play and stop nodes to initiate and terminate thetask, a GUI element may be displayed which is operable to controloperation of the graphical program. For example, the GUI element may beoperable to control start and/or stop operations of the task performedby the graphical program. In one embodiment, the GUI element may bedisplayed in the graphical program. For example, as FIG. 13B shows, inone embodiment, the GUI element may comprise a start/stop node which isconnected to the read node as shown, and which may be operable toinitiate and terminate execution of the task and/or the graphicalprogram. For example, the GUI element may be operable to receive userinput to invoke execution of the graphical program. Then, the GUIelement may be operable to receive further user input to terminateexecution of the graphical program. In one embodiment, the GUI elementmay be a toggle switch which operates to alternately control start andstop operations of the graphical program and/or task.

[0151] In the embodiment shown, the read node may operate to invoke theexpert system and run-time builder to generate the run-time, asdescribed in detail above. It should be noted that in anotherembodiment, the GUI element may be operable to receive the taskspecification, and invoke the expert system and run-time builder. Thus,the GUI element may serve to start and stop the repetitive task, and mayalso provide the functionality described above regarding the start node.

[0152] As FIG. 13C illustrates, in one embodiment, the GUI element maycomprise a terminal displayed in the graphical program which indicatesthat a corresponding control, e.g., displayed in a panel separate fromthe graphical program, may be operable to control start and/or stopoperations of the task performed by the graphical program or of thegraphical program itself.

[0153] As shown in FIG. 13D, in another embodiment, the GUI element maybe displayed in a panel separate from the graphical program, i.e., theGUI element may not be displayed in the graphical program at all. Inthis case, the fact that the operation is specified as “continuous”implies that a control (the GUI element) may be provided (in a separatepanel, menu, etc.) for starting and/or stopping execution of the taskand/or graphical program.

[0154]FIG. 13E illustrates an embodiment in which the configurationnodes described above are included in the graphical program. As FIG. 13Eshows, the node (in this case, a read node) is configured for continuousacquisition, and the GUI element comprises a terminal representing acontrol, such as a button or toggle switch, displayed elsewhere, asdescribed above. It should be noted that in another embodiment, the GUIelement displayed in FIG. 13E may be operable to receive user input tocontrol operation of the graphical program. Thus, in variousembodiments, the GUI element may be a passive terminal, or may be anactive control, as desired.

[0155] Turning now to FIG. 13F, a graphical program is shownillustrating a repetitive read or data acquisition task where the nodereceives a loop specification and a number of samples specification. Inthis example, the loop specification node indicates a value of 50 forthe repetitive task parameter mentioned above, thus, the program invokedby execution of the read node may iterate 50 times to perform therepetitive task. Additionally, as FIG. 13F shows, each iteration cycleof the program may acquire 100 samples, as indicated. Thus, in oneembodiment, the node may, in effect, include an implied “for loop”structure.

[0156]FIG. 14—A Method for Performing a Task Using a Loop Structure

[0157]FIG. 14 is a flowchart of one embodiment of a method forperforming a task using a loop structure in a graphical program. In oneembodiment, the method may operate as part of a measurement system, themethod being used to configure installed measurement hardware devicesand/or to create a program to operate the measurement system, althoughother domains of application are also contemplated. It is noted that theflowchart of FIG. 14 is exemplary only. Further, various steps in theflowchart of FIG. 14 may occur concurrently or in different order thanthat shown, or may be omitted, as desired. Also, various steps may beadded as desired.

[0158] As FIG. 14 shows, in 1402, a loop structure may be displayed in agraphical program, where the loop structure indicates that at least aportion of the task is to execute repetitively. The loop structure mayinclude an input terminal, also referred to as a loop entry terminal,representing performance of a first function. In other words, the inputterminal of the loop structure may be a graphical representation ofprogram instructions which are executable to perform the first function.

[0159] In 1404, the input terminal of the loop structure may beconfigured to receive an input. In one embodiment, the input maycomprise a task specification which specifies the task, as describedabove. In one embodiment, the graphical program may also display atleast one node representing the task specification. The input terminalof the loop structure may be configured to receive the input byconnecting the task specification node to the input terminal of the loopstructure.

[0160] In 1406, the input terminal of the loop structure may receive theinput, e.g., may receive the task specification as input. In otherwords, the graphical program may be executed, thereby invoking the inputterminal of the loop structure to receive the input, e.g., from the taskspecification node. In another embodiment, the input terminal mayreceive the task specification from a configuration node, as describedabove with reference to FIG. 13E.

[0161] The input terminal of the loop structure may then perform thefirst function in response to receiving the input, as indicated in 1408.The first function may provide various initialization, creation, orset-up operations for performing the specified task. For example, in oneembodiment, the first function may initialize one or more nodescontained within the loop structure. In another embodiment, the firstfunction may operate to generate a program based on the taskspecification, where the generated program may be executable toconfigure a device (or devices) to perform at least a portion of thetask. Various approaches for generating the program are described abovewith reference to FIGS. 7 and 12.

[0162] In one embodiment, the method may include receiving user inputselecting the first function to be performed by the input terminal ofthe loop structure. In other words, prior to executing the graphicalprogram, user input specifying the functionality of the first functionmay be received. For example, the functionality of the first functionmay be included in the task specification, which, as described above,may be generated based on received user input. Other examples offunctions which may be performed by the input terminal (the loop entryterminal) are described above with reference to FIGS. 13A-13F.

[0163] In 1410, the loop structure may invoke performance or executionof a second function. In one embodiment, the second function may berepresented by a node displayed in the loop structure, where the node isconnected to the input terminal of the loop structure (e.g., from insidethe loop structure). Thus, executing the graphical program may furtherinclude the input terminal of the loop structure providing an output tothe node, and the node performing the second function in response to thenode receiving the output. The loop structure may indicate that nodescontained in the loop structure are to execute repetitively, and thus,the node performing the second function may comprise the node performingthe second function repeatedly.

[0164] In another embodiment, one or more nodes may be displayed in theloop structure, where the one or more nodes represent performance orexecution of one or more second functions. At least one of the nodes maybe connected to the input terminal of the loop structure to receive theoutput from the input terminal of the loop structure, and the one ormore nodes may then perform the one or more second functions. In variousembodiments, the second function or functions may include one or moreof: acquiring data from the device, analyzing data received from thedevice, and/or generating data to the device. In other words, the secondfunction(s) may perform measurements, signal generation, and/oranalysis, as desired. It should be noted that the signal generation mayinclude generating a signal for testing, or for controlling an externalsystem or device, among others.

[0165] In one embodiment, the loop structure may also include an outputterminal, where the output terminal represents performance of a thirdfunction. In 1412, the loop structure, e.g., the output terminal of theloop structure, may invoke performance or execution of the thirdfunction. For example, the output of the node displayed in the loopstructure (or the output of at least one of the nodes displayed in theloop structure) may be connected to the output terminal of the loopstructure. Executing the graphical program may then include the nodeproviding an output to the output terminal of the loop structure, andthe output terminal of the loop structure performing the third functionin response to receiving the output from the node. In variousembodiments, the third function may perform any of a variety ofoperations related to the termination of the task. For example, thethird function may be operable to perform at least one of: discontinueoperation of the device, and perform clean-up operations related to thetask, e.g., de-allocation of memory, release of system resources, etc.,or other operations, as desired.

[0166] Thus, in one embodiment of the above method, the first functionmay create a program based on a received task specification, where thetask specification specifies a task. The program may then execute toconfigure a device to perform at least a portion of the task, e.g., byperforming the second function. The third function may then operate todiscontinue operation of the device, and/or to perform clean-upoperations related to the task. Thus, the loop structure may provide orinvoke various functions to perform the specified task. Further examplesof the use of the loop structure are provided below with reference toFIGS. 15A-15G.

[0167] It should be noted that in an exemplary embodiment of theinvention, the graphical program may be operable to perform ameasurement. In other words, the above-described method may operate aspart of a measurement system. However, the method may also be applied toperforming tasks in any other field as desired, including, but notlimited to, manufacturing, testing, machine vision and control, science,medicine, engineering, robotics, finance, and business, among others.

[0168] FIGS. 15A-15G—Loop Structure

[0169] FIGS. 15A-15G illustrate various embodiments of a loop structurein a graphical program which may be operable to invoke a program forperforming repetitive tasks. Various embodiments of the loop structuredescribed herein may be suitable for use in a variety of measurementsystems, as described above, but it is noted that the loop structure asdescribed may also be suitable for use in any applications which performiterative or repetitive tasks. The loop structure may be a primitivegraphical program element provided by a graphical programmingdevelopment environment for inclusion in the graphical program. Asdescribed above, in an exemplary embodiment, the graphical program maybe a LabVIEW graphical program, but other types of graphical programsare also contemplated.

[0170] Various embodiments of the loop structure described below mayperform similar functions as the repetitive task nodes described abovewith reference to FIGS. 13A-13F. However, whereas the node describedabove included implied looping functionality, various embodiments of theloop structure described below may include implied node functionality.In other words, the loop structure may perform certain functionsdescribed above with respect to various graphical program nodes. Itshould be noted that the examples of FIGS. 15A-15G are intended asexemplary embodiments of the invention, and are not intended to limitthe invention to any particular appearance, form, structure, orarchitecture.

[0171]FIG. 15A is a block diagram of a graphical program which includesa loop structure for performing a repetitive task, e.g., a repetitivemeasurement task. In one embodiment, the loop structure may beconfigured to receive a task specification 740 as input, where, asdescribed above, the task specification 740 specifies the task. The loopstructure may be executable in the graphical program to receive the taskspecification 740 as input, and invoke execution of a program to performthe task. The loop structure may indicate that the program is to iteratecontinuously, or a specified number of times, as specified by the taskspecification 740. In one embodiment, a node may be displayed in thegraphical program which represents a repetitive task parameter, as wasshown in FIGS. 13A-13F, described above. In this embodiment, the nodemay be connected to the loop structure to indicate that the program isto iterate repetitively in accordance with the repetitive taskparameter, i.e., continuously, or a specified number of times.

[0172] In one embodiment, the loop structure may also be executable togenerate the program based on the task specification 740. For example,similar to the node described above with reference to FIGS. 13A-13F, ingenerating the program, the loop structure may invoke an expert system750 to analyze the task specification 740, and generate the programbased on results of the expert system 750, where the program is operableto perform the task. In one embodiment, the expert system may analyzethe task specification 740 and generate a run-time specification 770 forthe task in response to the analyzing. The loop structure may alsoinvoke the expert system 750 to validate the task specification 740prior to generating the run-time specification 770. The loop structuremay then invoke a run-time builder 780 to analyze the run-timespecification 770 and generate a run-time 790 based on the run-timespecification 770, where the run-time 790 may be executable to performthe task. Thus, the generated run-time 790 may comprise the programwhich executes to perform the specified task.

[0173] The loop structure may also invoke the run-time builder 780 toconfigure one or more devices according to the run-time specification770. Thus, the loop structure may be executable to configure a device toperform the task. In this embodiment, the loop structure invokingexecution of the program to perform the task may include invokingexecution of the run-time 790 to perform the task. The run-time 790(i.e., the program) may then execute to perform the task using theconfigured devices.

[0174] In one example, the task may include a measurement. The loopstructure may configure the device to acquire data from a source, inwhich case the loop structure invoking execution of the program mayinclude the device acquiring data from the source, and the loopstructure acquiring the data from the device. In an embodiment where thegraphical program operates in a system comprising a computer system 102and the device 230, the loop structure acquiring data from the device230 may include the loop structure acquiring data from the device 230and providing the acquired data to the computer system 102, similar tothe read node, described above.

[0175] As another example, the task may include a signal generation, inwhich case the loop structure may configure the device to generatesignal data, and, by invoking execution of the program, may invokesignal generation by the device. If the graphical program operates inthe system mentioned above, including a computer system and the device,the loop structure invoking signal generation by the device may includethe loop structure acquiring data from the computer system and providingthe acquired data to the device. The device may then generate the signalbased on the acquired data. Thus, the task invoked or performed by theloop structure may comprise one or more measurements, and/or one or moresignal generations, as specified by the task specification. Although theloop structure described herein has been presented for use in any ofvarious applications, in an exemplary application of the presentinvention, the task may be a measurement task, where the taskspecification comprises a measurement task specification, and where thedevice comprises a measurement device. In other words, the loopstructure described may be suited for performing measurements and/orsignal generations in a computer based measurement system, among otherapplications.

[0176] As FIG. 15A also shows, in one embodiment, a node may bedisplayed inside the loop structure, where the loop structure indicatesthat the node is to execute repetitively or iteratively. In thisembodiment, the loop structure invoking execution of the program toperform the task may include the loop structure invoking execution ofthe node, and the node invoking execution of the program to perform thetask.

[0177] In one embodiment, the node may be executable to perform aportion of the task. For example, where the task includes a measurement,the node may be executable to acquire data from the device, i.e. mayfunction as a read node. Thus, in this embodiment, the loop structuremay be executable to configure the device to acquire data from a source,and invoking execution of the program may include the device acquiringdata from the source, and the node acquiring data from the device. Asdescribed above, in a computer based system, the node may acquire datafrom the device and provide the acquired data to the computer system. Inthe case that the task includes signal generation, the loop structuremay be executable to configure the device to generate signal data, andinvoke signal generation by the device by retrieving data from thecomputer and writing data to the device. In other words, the node mayfunction as a write node. Note that in other embodiments, other nodesbesides read and write nodes are also contemplated, as described below.

[0178] In one embodiment, the loop structure may include a loop entryterminal 1502, as shown in FIG. 15A. The loop entry terminal 1502 may beoperable to receive the task specification, invoke an expert system toanalyze the task specification and generate a runtime specification forthe task, and invoke a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification. As mentioned above, the run-time may then be executableto perform the task. Additionally, when the task is a repetitive task,the loop structure invoking execution of a program to perform the taskmay include the loop structure invoking two or more iteration cycles ofthe program to perform the task. In this case, the loop entry terminal1502, i.e., the loop structure, may be further operable to perform oneor more operations prior to or during a first iteration cycle of the twoor more iteration cycles of the program, such as initialization of datastructures, or special operations related to boundary conditions, asdescribed above with reference to FIGS. 13A-13F. Thus, in oneembodiment, the loop entry terminal 1502 may operate in a similar manneras the repetitive task nodes (e.g., the “play” node) described above. Inone embodiment, the loop entry terminal may execute to configure thedevice to acquire data from a source, and/or to generate signal data, asdescribed above.

[0179] The loop structure may also include a loop exit terminal 1504,also referred to as an output terminal, which may operate to terminatethe repetitive task, similar to the “stop” node described above. Inother words, the loop exit terminal 1504 may operate to terminate thespecified task, e.g., data acquisition by the measurement device, uponfulfillment of stopping conditions or user input. Where the loopstructure invokes two or more iteration cycles of the program to performthe task, the loop exit terminal 1504 may be further operable to performone or more operations during or after a final iteration cycle of thetwo or more iteration cycles of the program, such as various “clean up”operations, as also described above.

[0180]FIG. 15B is similar to the graphical program of FIG. 15A, butrather than using a start/stop terminal 1506 to initiate and terminatethe task, a GUI element may be displayed which is operable to controloperation of the graphical program, as described above with reference toFIG. 13B. In one embodiment, the GUI element may be displayed in thegraphical program. For example, as FIG. 15B shows, in one embodiment,the GUI element may comprise a start/stop node which is connected to theloop structure as shown, and which may be operable to initiate andterminate execution of the task and/or the graphical program. Forexample, the GUI element may be operable to receive user input to invokeexecution of the graphical program. Then, the GUI element may beoperable to receive further user input to terminate execution of thegraphical program. In one embodiment, the GUI element may be a toggleswitch which operates to alternately control start and stop operationsof the graphical program and/or task.

[0181] Turning now to FIG. 15C, in one embodiment, the graphical programmay include one or more nodes displayed inside the loop structure, wherethe loop structure indicates that the one or more nodes are to executerepetitively. The nodes may be executable to perform one or moreanalysis functions of the task, as indicated by FIGS. 15C and 15D. Inthis example, the loop structure includes implied “read node”functionality, i.e., the loop structure operates to retrieve acquireddata from a measurement device. The loop structure may provide theacquired data to the analysis node(s) for performing one or moreanalysis functions on the acquired data, then send the results and/orthe acquired data to the computer system. It should be noted than inother embodiments, the one or more nodes displayed inside the loopstructure may provide various other functions. For example, digital oranalog signal processing nodes may operate on the acquired data. Asanother example, a communication node may route data, analysis results,or alarms to an external system, such as a control system or a website.Thus, any of a variety of nodes may be included inside the loopstructure, as desired.

[0182] In another embodiment, the loop structure may not contain anynodes, as indicated by FIGS. 15E and 15F. In other words, the loopstructure may itself perform some or all of the functionality describedabove with reference to various graphical program nodes.

[0183] As mentioned above, in one embodiment, the loop structure mayinclude a loop entry terminal, also referred to as an input terminal,which is operable to receive the task specification. In particular, theloop entry terminal may be connected to an output terminal of a node inthe graphical program which may provide the task specification to theloop structure. For example, the node may be a task specification node,as illustrated in FIGS. 15A-15F, and described above.

[0184] In other embodiments, the node may be a configuration node whichoperates to configure the task specification for input to the loopstructure, as shown in FIG. 15G. In other words, the configuration nodemay operate in conjunction with one or more other configuration nodes togenerate the task specification. For example, as FIG. 15G shows, eachconfiguration node may comprises one of: a channel configuration node,operable to add channel configuration information to the taskspecification, a timing configuration node, operable to add timingconfiguration information to the task specification, and a triggeringconfiguration node, operable to add triggering configuration informationto the task specification. In other embodiments, other types ofconfiguration nodes are also contemplated. Thus, as FIG. 15G indicates,one or more configuration nodes may operate to configure or “fill” atask specification, e.g., a measurement task specification, withconfiguration information, e.g., derived from user input, and to providethe task specification to the loop structure.

[0185] As also described above with reference to FIGS. 13A-13E, invarious embodiments, the graphical program may include a GUI elementwhich may be operable to control operation of the graphical program. Inparticular, the GUI element may operate to control start and/or stopoperations of the task performed by the graphical program, as describedabove in detail. Two exemplary embodiments of the GUI element arepresented for each of the graphical programs illustrated in FIGS.15A-15F. More specifically, embodiments where the GUI element is a“start/stop” terminal 1506 are illustrated in FIGS. 15A, 15C, 15E, and15G, while embodiments where the GUI element is a “start/stop” nodeincluded in the graphical program are illustrated in FIGS. 15B, 15D, and15F. It should be noted than in another embodiment, the start/stopterminal 1506 may be implied, i.e., a start/stop control may be providedon a separate panel, but a corresponding terminal may not be displayedin the graphical program.

[0186] Finally, as also described above, in one embodiment, thegraphical program may be operable to receive user input selecting theloop structure, and display a more detailed graphical programrepresenting operations of the loop structure. In other words, variousof the functions performed by the loop structure which are implicit inthe loop structure, i.e., which are not represented graphically, may beexplicated by selection and/or activation of the loop structure icon inthe graphical program. For example, in an embodiment where the loopstructure implicitly includes read or write node functionality,double-clicking on the loop structure icon may result in the graphicalprogram displaying the corresponding read or write node inside the loopstructure. Similarly, implied analysis node functionality may beexplicitly represented by a displayed analysis node or nodes uponselection of the loop structure icon.

[0187] Thus, in various embodiments of the present invention, a loopstructure may be operable to receive a task specification and to invokeexecution of a program to perform a specified task based on the receivedtask specification. Additionally, the loop structure may be operable togenerate the program as well, such as by invoking an expert system andrun-time builder, as described in detail above. Finally, the loopstructure may be operable to provide various functions for performingthe specified task, including one or more of read and/or writeoperations, start/stop operations, analysis, communication, and signalprocessing, among others.

[0188] It should be noted that various embodiments may further includereceiving, sending or storing instructions and/or data implemented inaccordance with the foregoing description upon a carrier medium.Generally speaking, a carrier medium may include storage media or memorymedia such as magnetic or optical media, e.g., disk or CD-ROM, volatileor non-volatile media such as RAM (e.g. SDRAM, DDR SDRAM, RDRAM, SRAM,etc.), ROM, etc. as well as transmission media or signals such aselectrical, electromagnetic, or digital signals, conveyed via acommunication medium such as network and/or a wireless link.

[0189] Although the system and method of the present invention have beendescribed in connection with several embodiments, the invention is notintended to be limited to the specific forms set forth herein, but onthe contrary, it is intended to cover such alternatives, modifications,and equivalents as may be reasonably included within the spirit andscope of the invention as defined by the appended claims.

We claim:
 1. A method for creating a graphical program that performs atask, the method comprising: displaying a node in a graphical program;configuring the node to receive a task specification; and executing thenode in the graphical program, wherein said executing the nodecomprises: the node receiving a task specification as input, wherein thetask specification specifies a task; and the node invoking execution ofa program to perform the task.
 2. The method of claim 1, furthercomprising: the node generating a program which is operable to performthe task, wherein the node generates the program based on the taskspecification.
 3. The method of claim 2, wherein the node generating theprogram comprises: the node invoking an expert system to analyze thetask specification; and the node generating the program based on resultsof the expert system, wherein the program is operable to perform thetask.
 4. The method of claim 2, wherein the node generating the programcomprises: the node invoking an expert system to analyze the taskspecification and generate a run-time specification for the task inresponse to said analyzing; and the node invoking a run-time builder toanalyze the run-time specification and generate a run-time based on therun-time specification, wherein the run-time is executable to performthe task.
 5. The method of claim 4, further comprising: the expertsystem validating the task specification prior to generating therun-time specification.
 6. The method of claim 4, further comprising:the run-time builder configuring one or more devices according to therun-time specification, wherein said run-time executes to perform thetask using the configured one or more devices.
 7. The method of claim 4,wherein the node invoking execution of the program to perform the taskcomprises the node invoking execution of the run-time to perform thetask.
 8. The method of claim 1, further comprising: generating saidgraphical program programmatically.
 9. The method of claim 1, furthercomprising: displaying a graphical user interface (GUI) for specifyingthe task; receiving user input to the GUI indicating values for aplurality of parameters characterizing the task, wherein said values forthe plurality of parameters are useable in generating the taskspecification; and generating the task specification based on the valuesfor the plurality of parameters.
 10. The method of claim 9, furthercomprising: receiving user input to the GUI requesting programmaticgeneration of the graphical program; and generating said graphicalprogram programmatically in response to said user input requesting saidgeneration.
 11. The method of claim 1, wherein said configuring the nodeto receive a task specification comprises connecting an input terminalof the node to an output terminal of different node in the graphicalprogram.
 12. The method of claim 11, wherein said different node is atask specification node.
 13. The method of claim 11, wherein saiddifferent node is a configuration node which operates to configure thetask specification for input to the node.
 14. The method of claim 13,wherein said configuration node operates in conjunction with one or moreother configuration nodes to generate the task specification.
 15. Themethod of claim 13, wherein said configuration node comprises one of: achannel configuration node, which is operable to add channelconfiguration information to the task specification; a timingconfiguration node, which is operable to add timing configurationinformation to the task specification; and a triggering configurationnode, which is operable to add triggering configuration information tothe task specification.
 16. The method of claim 13, wherein the node isa primitive node provided by a graphical programming developmentenvironment for inclusion in the graphical program.
 17. The method ofclaim 11, wherein the node is further operable to be connected to one ormore of: a read node, which is operable to perform at least a portion ofthe task, wherein the task comprises a measurement; and a write node,which is operable to perform at least a portion of the task, wherein thetask comprises a signal generation.
 18. The method of claim 11, whereinthe node is further operable to be connected to one or more of: a readnode, which is operable to acquire data from a device, wherein the taskcomprises a measurement; and a write node, which is operable to writedata to a device, wherein the task comprises a signal generation. 19.The method of claim 18, wherein the task comprises a repetitive task,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the task; and the node performing one or more operationsduring or prior to a first iteration cycle of said two or more iterationcycles of the program.
 20. The method of claim 18, wherein the taskcomprises a repetitive task, the method further comprising: displaying astop node in the graphical program, wherein the stop node is connectedto said one or more of said read node and said write node, and whereinthe stop node is operable to terminate the task.
 21. The method of claim20, wherein the node invoking execution of the program to perform thetask comprises: the node invoking two or more iteration cycles of theprogram to perform the task; and the stop node performing one or moreoperations prior to or during a final iteration cycle of said two ormore iteration cycles of the program.
 22. The method of claim 11,wherein the task comprises a measurement, and wherein the node isfurther operable to acquire data from a device.
 23. The method of claim11, wherein the task comprises a measurement, the method furthercomprising: the node executing to configure a device to acquire datafrom a source; wherein the node invoking execution of a program toperform the task comprises: the device acquiring data from the source;and the node acquiring data from the device.
 24. The method of claim 23,wherein the method operates in a system comprising a computer system andthe device; and wherein the node acquiring data from the devicecomprises the node acquiring data from the device and providing theacquired data to the computer system.
 25. The method of claim 11,wherein the task comprises a signal generation, and wherein the node isfurther operable to write data to a device.
 26. The method of claim 11,wherein the task comprises a measurement, the method further comprising:the node executing to configure a device to perform a signal generation;wherein the node invoking execution of a program to perform the taskcomprises: the node invoking signal generation by the device; and thedevice generating a signal in response to said invocation.
 27. Themethod of claim 26, wherein the method operates in a system comprising acomputer system and the device; and wherein the node invoking signalgeneration by the device comprises the node acquiring data from thecomputer system and providing the acquired data to the device.
 28. Themethod of claim 11, wherein said graphical program comprises a LabVIEWgraphical program.
 29. The method of claim 11, wherein the taskcomprises one or more of: one or more measurements; and one or moresignal generations.
 30. The method of claim 11, wherein the taskcomprises a complex operation using a plurality of devices, wherein atleast one of the plurality of devices comprises a hardware device. 31.The method of claim 11, wherein the task comprises a complex operationusing a plurality of devices, wherein at least one of the plurality ofdevices comprises a virtual device.
 32. The method of claim 11, whereinsaid task specification comprises configuration information for one ormore devices; and wherein, after being configured with saidconfiguration information, the one or more devices are operable toperform the task.
 33. The method of claim 1, wherein the task comprisesa repetitive task, the method further comprising: configuring the nodeto perform the repetitive task;
 34. The method of claim 33, wherein saidconfiguring the node to perform the repetitive task comprises displayingthe node in a loop structure in the graphical program, wherein the loopstructure indicates that the node is to execute continuously or aspecified number of times.
 35. The method of claim 33, wherein saidconfiguring the node to perform the repetitive task comprises displayinga different node in the graphical program which represents a repetitivetask parameter; and connecting the node to the different node toindicate that the node is to execute repetitively in accordance with therepetitive task parameter.
 36. The method of claim 35, wherein saidrepetitive task parameter indicates that the node is to executecontinuously.
 37. The method of claim 35, wherein said repetitive taskparameter indicates that the node is to execute a specified number oftimes.
 38. The method of claim 33, further comprising: displaying a GUIelement which is operable to control operation of the graphical program.39. The method of claim 38, wherein the GUI element is operable tocontrol start and/or stop operations of the task performed by thegraphical program.
 40. The method of claim 38, wherein the GUI elementis displayed in a panel separate from the graphical program.
 41. Themethod of claim 38, wherein the GUI element is displayed in thegraphical program.
 42. The method of claim 38, further comprising:receiving first user input to said GUI element to invoke execution ofthe graphical program; and receiving second user input to said GUIelement to terminate execution of the graphical program.
 43. The methodof claim 38, wherein said GUI element comprises a toggle switch whichoperates to alternately control start and stop operations of thegraphical program.
 44. The method of claim 33, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations prior to or during a firstiteration cycle of said two or more iteration cycles of the program. 45.The method of claim 33, wherein the node invoking execution of a programto perform the task comprises: the node invoking two or more iterationcycles of the program to perform the task; and the node performing oneor more operations during or after a final iteration cycle of said twoor more iteration cycles of the program.
 46. The method of claim 1,further comprising: receiving user input selecting the node; anddisplaying a more detailed graphical program representing operations ofthe node.
 47. A carrier medium comprising program instructions forcreating a graphical program that performs a task, wherein the programinstructions are executable to perform: displaying a node in a graphicalprogram; configuring the node to receive a task specification; andexecuting the node in the graphical program, wherein said executing thenode comprises: the node receiving a task specification as input,wherein the task specification specifies a task; and the node invokingexecution of a program to perform the task.
 48. The carrier medium ofclaim 47, wherein said program instructions are further executable toperform: the node generating a program which is operable to perform thetask, wherein the node generates the program based on the taskspecification.
 49. The carrier medium of claim 48, wherein the nodegenerating the program comprises: the node invoking an expert system toanalyze the task specification; and the node generating a program basedon results of the expert system, wherein the program is operable toperform the task.
 50. The carrier medium of claim 48, wherein the nodegenerating the program comprises: the node invoking an expert system toanalyze the task specification and generate a run-time specification forthe task in response to said analyzing; the node invoking a run-timebuilder to analyze the run-time specification and generate a run-timebased on the run-time specification, wherein the run-time is executableto perform the task.
 51. The carrier medium of claim 50, wherein saidprogram instructions are further executable to perform: the expertsystem validating the task specification prior to generating therun-time specification.
 52. The carrier medium of claim 50, wherein saidprogram instructions are further executable to perform: the run-timebuilder configuring one or more devices according to the run-timespecification, wherein said run-time executes to perform the task usingthe configured one or more devices.
 53. The carrier medium of claim 50,wherein the node invoking execution of the program to perform the taskcomprises the node invoking execution of the run-time to perform thetask.
 54. The carrier medium of claim 47, wherein the programinstructions are further executable to perform: generating saidgraphical program programmatically.
 55. The carrier medium of claim 47,wherein the program instructions are further executable to perform:displaying a graphical user interface (GUI) for specifying the task;receiving user input to the GUI indicating a plurality of parameterscharacterizing the task, wherein said plurality of parameters is useablein generating the task specification; and generating the taskspecification.
 56. The carrier medium of claim 55, wherein the programinstructions are further executable to perform: receiving user input tothe GUI requesting programmatic generation of the graphical program; andgenerating said graphical program programmatically in response to saiduser input requesting said generation.
 57. The carrier medium of claim47, wherein said configuring the node to receive a task specificationcomprises connecting an input terminal of the node to an output terminalof different node in the graphical program.
 58. The carrier medium ofclaim 57, wherein said different node is a task specification node. 59.The carrier medium of claim 57, wherein said different node is aconfiguration node which operates to configure the task specificationfor input to the node.
 60. The carrier medium of claim 59, wherein saidconfiguration node comprises one of: a channel configuration node, whichis operable to add channel configuration information to the taskspecification; a timing configuration node, which is operable to addtiming configuration information to the task specification; and atriggering configuration node, which is operable to add triggeringconfiguration information to the task specification.
 61. The carriermedium of claim 59, wherein said configuration node operates inconjunction with one or more other configuration nodes to generate thetask specification.
 62. The carrier medium of claim 47, wherein the nodeis a primitive node provided by a graphical programming developmentenvironment for inclusion in the graphical program.
 63. The carriermedium of claim 47, wherein the node is further operable to be connectedto one or more of: a read node, which is operable to perform at least aportion of the task, wherein the task comprises a measurement; and awrite node, which is operable to perform at least a portion of the task,wherein the task comprises a signal generation.
 64. The carrier mediumof claim 47, wherein the node is operable to be connected to one or moreof: a read node, which is operable to acquire data from a device,wherein the task comprises a measurement; and a write node, which isoperable to write data to a device, wherein the task comprises a signalgeneration.
 65. The carrier medium of claim 64, wherein the taskcomprises a repetitive task, wherein the node invoking execution of aprogram to perform the task comprises: the node invoking two or moreiteration cycles of the program to perform the task; and the nodeperforming one or more operations during or prior to a first iterationcycle of said two or more iteration cycles of the program.
 66. Thecarrier medium of claim 64, wherein the task comprises a repetitivetask, wherein the program instructions are further executable toperform: displaying a stop node in the graphical program, wherein thestop node is connected to said one or more of said read node and saidwrite node, and wherein the stop node is operable to terminate the task.67. The carrier medium of claim 66, wherein the node invoking executionof the program to perform the task comprises: the node invoking two ormore iteration cycles of the program to perform the task; and the stopnode performing one or more operations prior to or during a finaliteration cycle of said two or more iteration cycles of the program. 68.The carrier medium of claim 64, wherein the program instructions arefurther executable to perform: displaying a stop node in the graphicalprogram, wherein the stop node is connected to said one or more of saidread node and said write node, and wherein the stop node is operable toterminate the task.
 69. The carrier medium of claim 47, wherein the taskcomprises a measurement, and wherein the node is further operable toacquire data from a device.
 70. The carrier medium of claim 47, whereinthe task comprises a measurement, wherein the program instructions arefurther executable to perform: the node executing to configure a deviceto acquire data from a source; wherein the node invoking execution of aprogram to perform the task comprises: the device acquiring data fromthe source; and the node acquiring data from the device.
 71. The carriermedium of claim 70, wherein the program instructions implement a portionof a system comprising a computer system and the device; and wherein thenode acquiring data from the device comprises the node acquiring datafrom the device and providing the acquired data to the computer system.72. The carrier medium of claim 47, wherein the task comprises a signalgeneration, and wherein the node is further operable to write data to adevice.
 73. The carrier medium of claim 47, wherein the task comprises asignal generation, wherein the program instructions are furtherexecutable to perform: the node executing to configure a device toperform a signal generation; wherein the node invoking execution of aprogram to perform the task comprises: the node invoking signalgeneration by the device; and the device generating a signal in responseto said invocation.
 74. The carrier medium of claim 73, wherein theprogram instructions implement a portion of a system comprising acomputer system and the device; and wherein the node invoking signalgeneration by the device comprises the node acquiring data from thecomputer system and providing the acquired data to the device.
 75. Thecarrier medium of claim 47, wherein said graphical program comprises aLabVIEW graphical program.
 76. The carrier medium of claim 47, whereinthe task comprises one or more of: one or more measurements; and one ormore signal generations.
 77. The carrier medium of claim 47, wherein thetask comprises a complex operation using a plurality of devices, whereinat least one of the plurality of devices comprises a hardware device.78. The carrier medium of claim 47, wherein the task comprises a complexoperation using a plurality of devices, wherein at least one of theplurality of devices comprises a virtual device.
 79. The carrier mediumof claim 47, wherein said task specification comprises configurationinformation for one or more devices; and wherein, after being configuredwith said configuration information, the one or more devices areoperable to perform the task.
 80. The carrier medium of claim 47,wherein the task comprises a repetitive task, wherein the programinstructions are further executable to perform: configuring the node toperform the repetitive task;
 81. The carrier medium of claim 80, whereinsaid configuring the node to perform the repetitive task comprisesdisplaying the node in a loop structure in the graphical program,wherein the loop structure indicates that the node is to executecontinuously or a specified number of times.
 82. The carrier medium ofclaim 80, wherein said configuring the node to perform the repetitivetask comprises: displaying a different node in the graphical programwhich represents a repetitive task parameter; and connecting the node tothe different node to indicate that the node is to execute repetitivelyin accordance with the repetitive task parameter.
 83. The carrier mediumof claim 82, wherein said repetitive task parameter indicates that thenode is to execute continuously.
 84. The carrier medium of claim 82,wherein said repetitive task parameter indicates that the node is toexecute a specified number of times.
 85. The carrier medium of claim 80,wherein the program instructions are further executable to perform:displaying a GUI element which is operable to control operation of thegraphical program.
 86. The carrier medium of claim 85, wherein the GUIelement is operable to control start and/or stop operations of the taskperformed by the graphical program.
 87. The carrier medium of claim 85,wherein the GUI element is displayed in a panel separate from thegraphical program.
 88. The carrier medium of claim 85, wherein the GUIelement is displayed in the graphical program.
 89. The carrier medium ofclaim 85, wherein the program instructions are further executable toperform: receiving first user input to said GUI element to invokeexecution of the graphical program; and receiving second user input tosaid GUI element to terminate execution of the graphical program. 90.The carrier medium of claim 85, wherein said GUI element comprises atoggle switch which operates to alternately control start and stopoperations of the graphical program.
 91. The carrier medium of claim 80,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the task; and the node performing one or more operationsprior to or during a first iteration cycle of said two or more iterationcycles of the program.
 92. The carrier medium of claim 80, wherein thenode invoking execution of a program to perform the task comprises: thenode invoking two or more iteration cycles of the program to perform thetask; and the node performing one or more operations during or after afinal iteration cycle of said two or more iteration cycles of theprogram.
 93. The carrier medium of claim 47, wherein the programinstructions are further executable to perform: receiving user inputselecting the node; and displaying a more detailed graphical programrepresenting operations of the node.
 94. A node in a graphical program,wherein the node is configurable to receive a task specification asinput, wherein the task specification specifies a task; and wherein thenode is executable in the graphical program to perform: receiving thetask specification as input; and invoking execution of a program toperform the task.
 95. The node of claim 94, wherein the node is furtherexecutable in the graphical program to perform: generating a programwhich is operable to perform the task, wherein the node generates theprogram based on the task specification.
 96. The node of claim 95,wherein generating the program comprises: invoking an expert system toanalyze the task specification; and generating a program based onresults of the expert system, wherein the program is operable to performthe task.
 97. The node of claim 95, wherein generating the programcomprises: invoking an expert system to analyze the task specificationand generate a run-time specification for the task in response to saidanalyzing; and invoking a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification, wherein the run-time is executable to perform the task.98. The node of claim 97, wherein generating the program furthercomprises: invoking the expert system to validate the task specificationprior to generating the run-time specification.
 99. The node of claim97, wherein generating the program further comprises: invoking therun-time builder to configure one or more devices according to therun-time specification, wherein said run-time executes to perform thetask using the configured one or more devices.
 100. The node of claim97, wherein invoking execution of the program to perform the taskcomprises invoking execution of the run-time to perform the task. 101.The node of claim 94, wherein the node is a primitive node provided by agraphical programming development environment for inclusion in thegraphical program.
 102. The node of claim 94, wherein the node isfurther operable to be connected to one or more of: a read node, whichis operable to perform at least a portion of the task, wherein the taskcomprises a measurement; and a write node, which is operable to performat least a portion of the task, wherein the task comprises a signalgeneration.
 103. The node of claim 94, wherein the node is operable tobe connected to one or more of: a read node, which is operable toacquire data from a device, wherein the task comprises a measurement;and a write node, which is operable to write data to a device, whereinthe task comprises a signal generation.
 104. The node of claim 103,wherein the task comprises a repetitive task, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations during or prior to a firstiteration cycle of said two or more iteration cycles of the program.105. The node of claim 103, wherein the task comprises a repetitivetask, and wherein the graphical program further comprises: a stop nodedisplayed in the graphical program, wherein the stop node is connectedto said one or more of said read node and said write node, and whereinthe stop node is operable to terminate the task.
 106. The node of claim105, wherein the node invoking execution of the program to perform thetask comprises: the node invoking two or more iteration cycles of theprogram to perform the task; and the stop node performing one or moreoperations prior to or during a final iteration cycle of said two ormore iteration cycles of the program.
 107. The node of claim 94, whereinthe task comprises a measurement, and wherein the node is furtheroperable to acquire data from a device.
 108. The node of claim 94,wherein the task comprises a measurement, wherein the programinstructions are further executable to perform: the node executing toconfigure a device to acquire data from a source; wherein the nodeinvoking execution of a program to perform the task comprises: thedevice acquiring data from the source; and the node acquiring data fromthe device.
 109. The node of claim 108, wherein the node implements aportion of a system comprising a computer system and the device; andwherein the node acquiring data from the device comprises the nodeacquiring data from the device and providing the acquired data to thecomputer system.
 110. The node of claim 94, wherein the task comprises asignal generation, and wherein the node is further operable to writedata to a device.
 111. The node of claim 94, wherein the task comprisesa signal generation, wherein the program instructions are furtherexecutable to perform: the node executing to configure a device toperform a signal generation; wherein the node invoking execution of aprogram to perform the task comprises: the node invoking signalgeneration by the device; and the device generating a signal in responseto said invocation.
 112. The node of claim 111, wherein the nodeimplements a portion of a system comprising a computer system and thedevice; and wherein the node invoking signal generation by the devicecomprises the node acquiring data from the computer system and providingthe acquired data to the device.
 113. The node of claim 94, wherein saidgraphical program comprises a LabVIEW graphical program.
 114. The nodeof claim 94, wherein the task comprises one or more of: one or moremeasurements; and one or more signal generations.
 115. The node of claim94, wherein the task comprises a complex operation using a plurality ofdevices, wherein at least one of the plurality of devices comprises ahardware device.
 116. The node of claim 94, wherein the task comprises acomplex operation using a plurality of devices, wherein at least one ofthe plurality of devices comprises a virtual device.
 117. The node ofclaim 94, wherein said task specification comprises configurationinformation for one or more devices; and wherein, after being configuredwith said configuration information, the one or more devices areoperable to perform the task.
 118. The node of claim 94, wherein thetask comprises a repetitive task, wherein the node is configurable toperform the repetitive task;
 119. The node of claim 118, wherein thenode is configurable to perform the repetitive task by displaying thenode in a loop structure in the graphical program, wherein the loopstructure indicates that the node is to execute continuously or aspecified number of times.
 120. The node of claim 118, wherein the nodeis configurable to perform the repetitive task by: displaying adifferent node in the graphical program which represents a repetitivetask parameter; and connecting the node to the different node toindicate that the node is to execute repetitively in accordance with therepetitive task parameter.
 121. The node of claim 120, wherein saidrepetitive task parameter indicates that the node is to executecontinuously.
 122. The node of claim 120, wherein said repetitive taskparameter indicates that the node is to execute a specified number oftimes.
 123. The node of claim 118, wherein the graphical programcomprises: a GUI element which is operable to control operation of thegraphical program.
 124. The node of claim 123, wherein the GUI elementis operable to control start and/or stop operations of the taskperformed by the graphical program.
 125. The node of claim 123, whereinthe GUI element is displayed in a panel separate from the graphicalprogram.
 126. The node of claim 123, wherein the GUI element isdisplayed in the graphical program.
 127. The node of claim 118, whereinsaid GUI element is operable to receive first user input to invokeexecution of the graphical program; and wherein said GUI element isfurther operable to receive second user input to terminate execution ofthe graphical program.
 128. The node of claim 123, wherein said GUIelement comprises a toggle switch which operates to alternately controlstart and stop operations of the graphical program.
 129. The node ofclaim 118, wherein the node invoking execution of a program to performthe task comprises: the node invoking two or more iteration cycles ofthe program to perform the task; and the node performing one or moreoperations prior to or during a first iteration cycle of said two ormore iteration cycles of the program.
 130. The node of claim 118,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the task; and the node performing one or more operationsduring or after a final iteration cycle of said two or more iterationcycles of the program.
 131. The node of claim 94, wherein the node isoperable to: receive user input selecting the node; and display a moredetailed graphical program representing operations of the node.
 132. Anode in a graphical program which is operable to: receive a taskspecification as input, wherein the task specification specifies a task;and invoke execution of a program to perform the task.
 133. A node in agraphical program which is operable to: receive a task specification asinput, wherein the task specification specifies a task; and generate aprogram which is operable to perform the task.
 134. A node in agraphical program which is operable to: receive a task specification asinput, wherein the task specification specifies a task; invoke an expertsystem to analyze the task specification; and generate a program basedon results of the expert system, wherein the program is operable toperform the task.
 135. The node of claim 134, wherein the node isfurther operable to: invoke a run-time builder to analyze the run-timespecification and generate a runtime based on the run-timespecification, wherein said run-time is executable to perform the task;and invoke execution of said run-time to perform the task.
 136. A methodfor creating a graphical program that performs a measurement task, themethod comprising: displaying a node in a graphical program; configuringthe node to receive a measurement task specification; and executing thenode in the graphical program, wherein said executing the nodecomprises: the node receiving a measurement task specification as input,wherein the measurement task specification specifies a measurement task;and the node invoking execution of a program to perform the measurementtask.
 137. The method of claim 136, further comprising: the nodegenerating a program which is operable to perform the measurement task,wherein the node generates the program based on the measurement taskspecification.
 138. The method of claim 137, wherein the node generatingthe program comprises: the node invoking an expert system to analyze themeasurement task specification; and the node generating the programbased on results of the expert system, wherein the program is operableto perform the measurement task.
 139. The method of claim 137, whereinthe node generating the program comprises: the node invoking an expertsystem to analyze the measurement task specification and generate arun-time specification for the measurement task in response to saidanalyzing; and the node invoking a run-time builder to analyze therun-time specification and generate a run-time based on the run-timespecification, wherein the run-time is executable to perform themeasurement task.
 140. The method of claim 139, further comprising: theexpert system validating the measurement task specification prior togenerating the run-time specification.
 141. The method of claim 139,further comprising: the run-time builder configuring one or moremeasurement devices according to the run-time specification, whereinsaid run-time executes to perform the measurement task using theconfigured one or more measurement devices.
 142. The method of claim139, wherein the node invoking execution of the program to perform themeasurement task comprises the node invoking execution of the run-timeto perform the measurement task.
 143. The method of claim 136, furthercomprising: generating said graphical program programmatically.
 144. Themethod of claim 136, further comprising: displaying a graphical userinterface (GUI) for specifying the measurement task; receiving userinput to the GUI indicating values for a plurality of parameterscharacterizing the measurement task, wherein said values for theplurality of parameters are useable in generating the measurement taskspecification; and generating the measurement task specification basedon the values for the plurality of parameters.
 145. The method of claim144, further comprising: receiving user input to the GUI requestingprogrammatic generation of the graphical program; and generating saidgraphical program programmatically in response to said user inputrequesting said generation.
 146. The method of claim 136, wherein saidconfiguring the node to receive a measurement task specificationcomprises connecting an input terminal of the node to an output terminalof different node in the graphical program.
 147. The method of claim146, wherein said different node is a measurement task specificationnode.
 148. The method of claim 146, wherein said different node is aconfiguration node which operates to configure the measurement taskspecification for input to the node.
 149. The method of claim 148,wherein said configuration node operates in conjunction with one or moreother configuration nodes to generate the measurement taskspecification.
 150. The method of claim 148, wherein said configurationnode comprises one of: a channel configuration node, which is operableto add channel configuration information to the measurement taskspecification; a timing configuration node, which is operable to addtiming configuration information to the measurement task specification;and a triggering configuration node, which is operable to add triggeringconfiguration information to the measurement task specification. 151.The method of claim 148, wherein the node is a primitive node providedby a graphical programming development environment for inclusion in thegraphical program.
 152. The method of claim 146, wherein the node isfurther operable to be connected to one or more of: a read node, whichis operable to perform at least a portion of the measurement task,wherein the measurement task comprises a measurement; and a write node,which is operable to perform at least a portion of the measurement task,wherein the measurement task comprises a signal generation.
 153. Themethod of claim 146, wherein the node is further operable to beconnected to one or more of: a read node, which is operable to acquiredata from a measurement device, wherein the measurement task comprises ameasurement; and a write node, which is operable to write data to ameasurement device, wherein the measurement task comprises a signalgeneration.
 154. The method of claim 153, wherein the measurement taskcomprises a repetitive measurement task, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the measurementtask; and the node performing one or more operations during or prior toa first iteration cycle of said two or more iteration cycles of theprogram.
 155. The method of claim 153, wherein the measurement taskcomprises a repetitive measurement task, the method further comprising:displaying a stop node in the graphical program, wherein the stop nodeis connected to said one or more of said read node and said write node,and wherein the stop node is operable to terminate the measurement task.156. The method of claim 155, wherein the node invoking execution of theprogram to perform the measurement task comprises: the node invoking twoor more iteration cycles of the program to perform the task; and thestop node performing one or more operations prior to or during a finaliteration cycle of said two or more iteration cycles of the program.157. The method of claim 146, wherein the measurement task comprises ameasurement, and wherein the node is further operable to acquire datafrom a measurement device.
 158. The method of claim 146, wherein themeasurement task comprises a measurement, the method further comprising:the node executing to configure a measurement device to acquire datafrom a source; wherein the node invoking execution of a program toperform the measurement task comprises: the measurement device acquiringdata from the source; and the node acquiring data from the measurementdevice.
 159. The method of claim 158, wherein the method operates in ameasurement system comprising a computer system and the measurementdevice; and wherein the node acquiring data from the measurement devicecomprises the node acquiring data from the measurement device andproviding the acquired data to the computer system.
 160. The method ofclaim 146, wherein the measurement task comprises a signal generation,and wherein the node is further operable to write data to a measurementdevice.
 161. The method of claim 146, wherein the measurement taskcomprises a measurement, the method further comprising: the nodeexecuting to configure a measurement device to perform a signalgeneration; wherein the node invoking execution of a program to performthe measurement task comprises: the node invoking signal generation bythe measurement device; and the measurement device generating a signalin response to said invocation.
 162. The method of claim 161, whereinthe method operates in a measurement system comprising a computer systemand the measurement device; and wherein the node invoking signalgeneration by the measurement device comprises the node acquiring datafrom the computer system and providing the acquired data to themeasurement device.
 163. The method of claim 146, wherein said graphicalprogram comprises a LabVIEW graphical program.
 164. The method of claim146, wherein the measurement task comprises one or more of: one or moremeasurements; and one or more signal generations.
 165. The method ofclaim 146, wherein the measurement task comprises a complex measurementoperation using a plurality of measurement devices, wherein at least oneof the plurality of measurement devices comprises a measurement hardwaredevice.
 166. The method of claim 146, wherein the measurement taskcomprises a complex measurement operation using a plurality ofmeasurement devices, wherein at least one of the plurality ofmeasurement devices comprises a virtual measurement device.
 167. Themethod of claim 146, wherein said measurement task specificationcomprises configuration information for one or more measurement devices;and wherein, after being configured with said configuration information,the one or more measurement devices are operable to perform themeasurement task.
 168. The method of claim 136, wherein the measurementtask comprises a repetitive measurement task, the method furthercomprising: configuring the node to perform the repetitive measurementtask;
 169. The method of claim 168, wherein said configuring the node toperform the repetitive measurement task comprises displaying the node ina loop structure in the graphical program, wherein the loop structureindicates that the node is to execute continuously or a specified numberof times.
 170. The method of claim 168, wherein said configuring thenode to perform the repetitive measurement task comprises displaying adifferent node in the graphical program which represents a repetitivemeasurement task parameter; and connecting the node to the differentnode to indicate that the node is to execute repetitively in accordancewith the repetitive measurement task parameter.
 171. The method of claim170, wherein said repetitive measurement task parameter indicates thatthe node is to execute continuously.
 172. The method of claim 170,wherein said repetitive measurement task parameter indicates that thenode is to execute a specified number of times.
 173. The method of claim168, further comprising: displaying a GUI element which is operable tocontrol operation of the graphical program.
 174. The method of claim173, wherein the GUI element is operable to control start and/or stopoperations of the measurement task performed by the graphical program.175. The method of claim 173, wherein the GUI element is displayed in apanel separate from the graphical program.
 176. The method of claim 173,wherein the GUI element is displayed in the graphical program.
 177. Themethod of claim 173, further comprising: receiving first user input tosaid GUI element to invoke execution of the graphical program; andreceiving second user input to said GUI element to terminate executionof the graphical program.
 178. The method of claim 173, wherein said GUIelement comprises a toggle switch which operates to alternately controlstart and stop operations of the measurement task performed by thegraphical program.
 179. The method of claim 168, wherein the nodeinvoking execution of a program to perform the measurement taskcomprises: the node invoking two or more iteration cycles of the programto perform the measurement task; and the node performing one or moreoperations prior to or during a first iteration cycle of said two ormore iteration cycles of the program.
 180. The method of claim 168,wherein the node invoking execution of a program to perform themeasurement task comprises: the node invoking two or more iterationcycles of the program to perform the measurement task; and the nodeperforming one or more operations during or after a final iterationcycle of said two or more iteration cycles of the program.
 181. Themethod of claim 136, further comprising: receiving user input selectingthe node; and displaying a more detailed graphical program representingoperations of the node.
 182. A carrier medium comprising programinstructions for creating a graphical program that performs ameasurement task, wherein the program instructions are executable toperform: displaying a node in a graphical program; configuring the nodeto receive a measurement task specification; and executing the node inthe graphical program, wherein said executing the node comprises: thenode receiving a measurement task specification as input, wherein themeasurement task specification specifies a measurement task; and thenode invoking execution of a program to perform the measurement task.183. The carrier medium of claim 182, wherein said program instructionsare further executable to perform: the node generating a program whichis operable to perform the measurement task, wherein the node generatesthe program based on the measurement task specification.
 184. Thecarrier medium of claim 183, wherein the node generating the programcomprises: the node invoking an expert system to analyze the measurementtask specification; and the node generating a program based on resultsof the expert system, wherein the program is operable to perform themeasurement task.
 185. The carrier medium of claim 183, wherein the nodegenerating the program comprises: the node invoking an expert system toanalyze the measurement task specification and generate a run-timespecification for the measurement task in response to said analyzing;the node invoking a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification, wherein the run-time is executable to perform themeasurement task.
 186. The carrier medium of claim 185, wherein saidprogram instructions are further executable to perform: the expertsystem validating the measurement task specification prior to generatingthe run-time specification.
 187. The carrier medium of claim 185,wherein said program instructions are further executable to perform: therun-time builder configuring one or more measurement devices accordingto the run-time specification, wherein said run-time executes to performthe measurement task using the configured one or more measurementdevices.
 188. The carrier medium of claim 185, wherein the node invokingexecution of the program to perform the measurement task comprises thenode invoking execution of the run-time to perform the measurement task.189. The carrier medium of claim 182, wherein the program instructionsare further executable to perform: generating said graphical programprogrammatically.
 190. The carrier medium of claim 182, wherein theprogram instructions are further executable to perform: displaying agraphical user interface (GUI) for specifying the measurement task;receiving user input to the GUI indicating a plurality of parameterscharacterizing the measurement task, wherein said plurality ofparameters is useable in generating the measurement task specification;and generating the measurement task specification.
 191. The carriermedium of claim 190, wherein the program instructions are furtherexecutable to perform: receiving user input to the GUI requestingprogrammatic generation of the graphical program; and generating saidgraphical program programmatically in response to said user inputrequesting said generation.
 192. The carrier medium of claim 182,wherein said configuring the node to receive a measurement taskspecification comprises connecting an input terminal of the node to anoutput terminal of different node in the graphical program.
 193. Thecarrier medium of claim 192, wherein said different node is ameasurement task specification node.
 194. The carrier medium of claim192, wherein said different node is a configuration node which operatesto configure the measurement task specification for input to the node.195. The carrier medium of claim 194, wherein said configuration nodecomprises one of: a channel configuration node, which is operable to addchannel configuration information to the measurement task specification;a timing configuration node, which is operable to add timingconfiguration information to the measurement task specification; and atriggering configuration node, which is operable to add triggeringconfiguration information to the measurement task specification. 196.The carrier medium of claim 194, wherein said configuration nodeoperates in conjunction with one or more other configuration nodes togenerate the measurement task specification.
 197. The carrier medium ofclaim 182, wherein the node is a primitive node provided by a graphicalprogramming development environment for inclusion in the graphicalprogram.
 198. The carrier medium of claim 182, wherein the node isfurther operable to be connected to one or more of: a read node, whichis operable to perform at least a portion of the measurement task,wherein the measurement task comprises a measurement; and a write node,which is operable to perform at least a portion of the measurement task,wherein the measurement task comprises a signal generation.
 199. Thecarrier medium of claim 182, wherein the node is operable to beconnected to one or more of: a read node, which is operable to acquiredata from a measurement device, wherein the measurement task comprises ameasurement; and a write node, which is operable to write data to ameasurement device, wherein the measurement task comprises a signalgeneration.
 200. The carrier medium of claim 199, wherein themeasurement task comprises a repetitive measurement task, wherein thenode invoking execution of a program to perform the measurement taskcomprises: the node invoking two or more iteration cycles of the programto perform the measurement task; and the node performing one or moreoperations during or prior to a first iteration cycle of said two ormore iteration cycles of the program.
 201. The carrier medium of claim199, wherein the measurement task comprises a repetitive task, whereinthe program instructions are further executable to perform: displaying astop node in the graphical program, wherein the stop node is connectedto said one or more of said read node and said write node, and whereinthe stop node is operable to terminate the measurement task.
 202. Thecarrier medium of claim 201, wherein the node invoking execution of theprogram to perform the measurement task comprises: the node invoking twoor more iteration cycles of the program to perform the measurement task;and the stop node performing one or more operations prior to or during afinal iteration cycle of said two or more iteration cycles of theprogram.
 203. The carrier medium of claim 137, wherein the measurementtask comprises a measurement, and wherein the node is further operableto acquire data from a measurement device.
 204. The carrier medium ofclaim 182, wherein the measurement task comprises a measurement, whereinthe program instructions are further executable to perform: the nodeexecuting to configure a measurement device to acquire data from asource; wherein the node invoking execution of a program to perform themeasurement task comprises: the measurement device acquiring data fromthe source; and the node acquiring data from the measurement device.205. The carrier medium of claim 204, wherein the program instructionsimplement a portion of a measurement system comprising a computer systemand the measurement device; and wherein the node acquiring data from themeasurement device comprises the node acquiring data from themeasurement device and providing the acquired data to the computersystem.
 206. The carrier medium of claim 182, wherein the measurementtask comprises a signal generation, and wherein the node is furtheroperable to write data to a measurement device.
 207. The carrier mediumof claim 182, wherein the measurement task comprises a signalgeneration, wherein the program instructions are further executable toperform: the node executing to configure a measurement device to performa signal generation; wherein the node invoking execution of a program toperform the measurement task comprises: the node invoking signalgeneration by the measurement device; and the measurement devicegenerating a signal in response to said invocation.
 208. The carriermedium of claim 207, wherein the program instructions implement aportion of a measurement system comprising a computer system and themeasurement device; and wherein the node invoking signal generation bythe measurement device comprises the node acquiring data from thecomputer system and providing the acquired data to the measurementdevice.
 209. The carrier medium of claim 182, wherein said graphicalprogram comprises a LabVIEW graphical program.
 210. The carrier mediumof claim 182, wherein the measurement task comprises one or more of: oneor more measurements; and one or more signal generations.
 211. Thecarrier medium of claim 182, wherein the measurement task comprises acomplex measurement operation using a plurality of measurement devices,wherein at least one of the plurality of measurement devices comprises ameasurement hardware device.
 212. The carrier medium of claim 182,wherein the measurement task comprises a complex measurement operationusing a plurality of measurement devices, wherein at least one of theplurality of measurement devices comprises a virtual measurement device.213. The carrier medium of claim 182, wherein said measurement taskspecification comprises configuration information for one or moremeasurement devices; and wherein, after being configured with saidconfiguration information, the one or more measurement devices areoperable to perform the measurement task.
 214. The carrier medium ofclaim 182, wherein the measurement task comprises a repetitivemeasurement task, wherein the program instructions are furtherexecutable to perform: configuring the node to perform the repetitivemeasurement task;
 215. The carrier medium of claim 214, wherein saidconfiguring the node to perform the repetitive measurement taskcomprises displaying the node in a loop structure in the graphicalprogram, wherein the loop structure indicates that the node is toexecute continuously or a specified number of times.
 216. The carriermedium of claim 214, wherein said configuring the node to perform therepetitive measurement task comprises displaying a different node in thegraphical program which represents a repetitive measurement taskparameter; and connecting the node to the different node to indicatethat the node is to execute repetitively in accordance with therepetitive measurement task parameter.
 217. The carrier medium of claim216, wherein said repetitive measurement task parameter indicates thatthe node is to execute continuously.
 218. The carrier medium of claim216, wherein said repetitive measurement task parameter indicates thatthe node is to execute a specified number of times.
 219. The carriermedium of claim 214, wherein the program instructions are furtherexecutable to perform: displaying a GUI element which is operable tocontrol operation of the graphical program.
 220. The carrier medium ofclaim 219, wherein the GUI element is operable to control start and/orstop operations of the task performed by the graphical program.
 221. Thecarrier medium of claim 219, wherein the GUI element is displayed in apanel separate from the graphical program.
 222. The carrier medium ofclaim 219, wherein the GUI element is displayed in the graphicalprogram.
 223. The carrier medium of claim 219, wherein the programinstructions are further executable to perform: receiving first userinput to said GUI element to invoke execution of the graphical program;and receiving second user input to said GUI element to terminateexecution of the graphical program.
 224. The carrier medium of claim219, wherein said GUI element comprises a toggle switch which operatesto alternately control start and stop operations of the graphicalprogram.
 225. The carrier medium of claim 214, wherein the node invokingexecution of a program to perform, the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations prior to or during a firstiteration cycle of said two or more iteration cycles of the program.226. The carrier medium of claim 214, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations during or after a final iterationcycle of said two or more iteration cycles of the program.
 227. Thecarrier medium of claim 182, wherein the program instructions arefurther executable to perform: receiving user input selecting the node;and displaying a more detailed graphical program representing operationsof the node.
 228. A node in a graphical program, wherein the node isconfigurable to receive a measurement task specification as input,wherein the measurement task specification specifies a measurement task;and wherein the node is executable in the graphical program to perform:receiving the measurement task specification as input; and invokingexecution of a program to perform the measurement task.
 229. The node ofclaim 228, wherein the node is further executable in the graphicalprogram to perform: generating a program which is operable to performthe measurement task, wherein the node generates the program based onthe measurement task specification.
 230. The node of claim 229, whereingenerating the program comprises: invoking an expert system to analyzethe measurement task specification; and generating a program based onresults of the expert system, wherein the program is operable to performthe measurement task.
 231. The node of claim 229, wherein generating theprogram comprises: invoking an expert system to analyze the measurementtask specification and generate a run-time specification for themeasurement task in response to said analyzing; and invoking a run-timebuilder to analyze the run-time specification and generate a run-timebased on the run-time specification, wherein the run-time is executableto perform the measurement task.
 232. The node of claim 231, whereingenerating the program further comprises: invoking the expert system tovalidate the measurement task specification prior to generating therun-time specification.
 233. The node of claim 231, wherein generatingthe program further comprises: invoking the run-time builder toconfigure one or more measurement devices according to the run-timespecification, wherein said run-time executes to perform the measurementtask using the configured one or more measurement devices.
 234. The nodeof claim 231, wherein invoking execution of the program to perform themeasurement task comprises invoking execution of the run-time to performthe measurement task.
 235. The node of claim 228, wherein the node is aprimitive node provided by a graphical programming developmentenvironment for inclusion in the graphical program.
 236. The node ofclaim 228, wherein the node is further operable to be connected to oneor more of: a read node, which is operable to perform at least a portionof the measurement task, wherein the measurement task comprises ameasurement; and a write node, which is operable to perform at least aportion of the measurement task, wherein the measurement task comprisesa signal generation.
 237. The node of claim 228, wherein the node isoperable to be connected to one or more of: a read node, which isoperable to acquire data from a measurement device, wherein themeasurement task comprises a measurement; and a write node, which isoperable to write data to a measurement device, wherein the measurementtask comprises a signal generation.
 238. The node of claim 237, whereinthe task comprises a repetitive task, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations during or prior to a firstiteration cycle of said two or more iteration cycles of the program.239. The node of claim 337, wherein the task comprises a repetitivetask, and wherein the graphical program further comprises: a stop nodedisplayed in the graphical program, wherein the stop node is connectedto said one or more of said read node and said write node, and whereinthe stop node is operable to terminate the task.
 240. The node of claim239, wherein the node invoking execution of the program to perform thetask comprises: the node invoking two or more iteration cycles of theprogram to perform the task; and the stop node performing one or moreoperations prior to or during a final iteration cycle of said two ormore iteration cycles of the program.
 241. The node of claim 228,wherein the measurement task comprises a measurement, and wherein thenode is further operable to acquire data from a measurement device. 242.The node of claim 228, wherein the measurement task comprises ameasurement, wherein the program instructions are further executable toperform: the node executing to configure a measurement device to acquiredata from a source; wherein the node invoking execution of a program toperform the measurement task comprises: the measurement device acquiringdata from the source; and the node acquiring data from the measurementdevice.
 243. The node of claim 242, wherein the node implements aportion of a measurement system comprising a computer system and themeasurement device; and wherein the node acquiring data from themeasurement device comprises the node acquiring data from themeasurement device and providing the acquired data to the computersystem.
 244. The node of claim 228, wherein the measurement taskcomprises a signal generation, and wherein the node is further operableto write data to a measurement device.
 245. The node of claim 228,wherein the measurement task comprises a signal generation, wherein theprogram instructions are further executable to perform: the nodeexecuting to configure a measurement device to perform a signalgeneration; wherein the node invoking execution of a program to performthe measurement task comprises: the node invoking signal generation bythe measurement device; and the measurement device generating a signalin response to said invocation.
 246. The node of claim 245, wherein thenode implements a portion of a measurement system comprising a computersystem and the measurement device; and wherein the node invoking signalgeneration by the measurement device comprises the node acquiring datafrom the computer system and providing the acquired data to themeasurement device.
 247. The node of claim 228, wherein said graphicalprogram comprises a LabVIEW graphical program.
 248. The node of claim228, wherein the measurement task comprises one or more of: one or moremeasurements; and one or more signal generations.
 249. The node of claim228, wherein the measurement task comprises a complex measurementoperation using a plurality of measurement devices, wherein at least oneof the plurality of measurement devices comprises a measurement hardwaredevice.
 250. The node of claim 228, wherein the measurement taskcomprises a complex measurement operation using a plurality ofmeasurement devices, wherein at least one of the plurality ofmeasurement devices comprises a virtual measurement device.
 251. Thenode of claim 228, wherein said measurement task specification comprisesconfiguration information for one or more measurement devices; andwherein, after being configured with said configuration information, theone or more measurement devices are operable to perform the measurementtask.
 252. The node of claim 228, wherein the measurement task comprisesa repetitive measurement task, wherein the node is configurable toperform the repetitive measurement task;
 253. The node of claim 252,wherein the node is configurable to perform the repetitive measurementtask by displaying the node in a loop structure in the graphicalprogram, wherein the loop structure indicates that the node is toexecute continuously or a specified number of times.
 254. The node ofclaim 252, wherein the node is configurable to perform the repetitivemeasurement task by: displaying a different node in the graphicalprogram which represents a repetitive measurement task parameter; andconnecting the node to the different node to indicate that the node isto execute repetitively in accordance with the repetitive measurementtask parameter.
 255. The node of claim 254, wherein said repetitivemeasurement task parameter indicates that the node is to executecontinuously.
 256. The node of claim 254, wherein said repetitivemeasurement task parameter indicates that the node is to execute aspecified number of times.
 257. The node of claim 252, wherein thegraphical program comprises: a GUI element which is operable to controloperation of the graphical program.
 258. The node of claim 257, whereinthe GUI element is operable to control start and/or stop operations ofthe task performed by the graphical program.
 259. The node of claim 258,wherein the GUI element is displayed in a panel separate from thegraphical program.
 260. The node of claim 258, wherein the GUI elementis displayed in the graphical program.
 261. The node of claim 258,wherein said GUI element is operable to receive first user input toinvoke execution of the graphical program; and wherein said GUI elementis further operable to receive second user input to terminate executionof the graphical program.
 262. The node of claim 258, wherein said GUIelement comprises a toggle switch which operates to alternately controlstart and stop operations of the graphical program.
 263. The node ofclaim 252, wherein the node invoking execution of a program to performthe task comprises: the node invoking two or more iteration cycles ofthe program to perform the task; and the node performing one or moreoperations prior to or during a first iteration cycle of said two ormore iteration cycles of the program.
 264. The node of claim 252,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the task; and the node performing one or more operationsduring or after a final iteration cycle of said two or more iterationcycles of the program.
 265. The graphical program of claim 228, whereinthe node is operable to: receive user input selecting the node; anddisplay a more detailed graphical program representing operations of thenode.
 266. A node in a graphical program which is operable to: receive ameasurement task specification as input, wherein the measurement taskspecification specifies a measurement task; and invoke execution of aprogram to perform the measurement task.
 267. A node in a graphicalprogram which is operable to: receive a measurement task specificationas input, wherein the measurement task specification specifies ameasurement task; and generate a program which is operable to performthe measurement task.
 268. A node in a graphical program which isoperable to: receive a measurement task specification as input, whereinthe measurement task specification specifies a measurement task; invokean expert system to analyze the measurement task specification; andgenerate a program based on results of the expert system, wherein theprogram is operable to perform the measurement task.
 269. The node ofclaim 268, wherein the node is further operable to: invoke a run-timebuilder to analyze the run-time specification and generate a runtimebased on the run-time specification, wherein said run-time is executableto perform the measurement task; and invoke execution of said run-timeto perform the measurement task.
 270. A method for creating a graphicalprogram that performs a measurement task, the method comprising:displaying a node in a graphical program; configuring the node toreceive a measurement task specification; executing the node in thegraphical program, wherein said executing the node comprises: the nodereceiving the measurement task specification; the node invoking anexpert system to analyze the measurement task specification and generatea run-time specification for the measurement task in response to saidanalyzing; the node invoking a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification, wherein said run-time is executable to perform themeasurement task; and the node invoking execution of said run-time toperform the measurement task.
 271. The method of claim 270, furthercomprising: displaying a graphical user interface (GUI) for specifyingthe measurement task; receiving user input to the GUI indicating valuesfor a plurality of parameters characterizing the measurement task,wherein said values for the plurality of parameters are useable ingenerating the measurement task specification; and generating themeasurement task specification based on the values for the plurality ofparameters.
 272. The method of claim 270, further comprising: generatingsaid graphical program programmatically.
 273. The method of claim 270,further comprising: receiving user input to the GUI requestingprogrammatic generation of the graphical program; and generating saidgraphical program programmatically in response to said user inputrequesting said generation.
 274. The method of claim 270, wherein saidconfiguring the node to receive a measurement task specificationcomprises connecting an input terminal of the node to an output terminalof different node in the graphical program.
 275. The method of claim274, wherein said different node is a measurement task specificationnode.
 276. The method of claim 274, wherein said different node is aconfiguration node which operates to configure the measurement taskspecification for input to the node.
 277. The method of claim 276,wherein said configuration node operates in conjunction with one or moreother configuration nodes to generate the measurement taskspecification.
 278. The method of claim 270, wherein the node is aprimitive node provided by a graphical programming developmentenvironment for inclusion in the graphical program.
 279. The method ofclaim 270, wherein the node is further operable to be connected to oneor more of: a read node, which is operable to perform at least a portionof the measurement task, wherein the measurement task comprises ameasurement; and a write node, which is operable to perform at least aportion of the measurement task, wherein the measurement task comprisesa signal generation.
 280. The method of claim 270, wherein the node isfurther operable to be connected to one or more of: a read node, whichis operable to acquire data from a measurement device, wherein themeasurement task comprises a measurement; and a write node, which isoperable to write data to a measurement device, wherein the measurementtask comprises a signal generation.
 281. The method of claim 280,wherein the measurement task comprises a repetitive measurement task,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the measurement task; and the node performing one or moreoperations during or prior to a first iteration cycle of said two ormore iteration cycles of the program.
 282. The method of claim 280,wherein the measurement task comprises a repetitive measurement task,the method further comprising: displaying a stop node in the graphicalprogram, wherein the stop node is connected to said one or more of saidread node and said write node, and wherein the stop node is operable toterminate the measurement task.
 283. The method of claim 282, whereinthe node invoking execution of the program to perform the measurementtask comprises: the node invoking two or more iteration cycles of theprogram to perform the task; and the stop node performing one or moreoperations prior to or during a final iteration cycle of said two ormore iteration cycles of the program.
 284. The method of claim 270,wherein the measurement task comprises a measurement, and wherein thenode is further operable to acquire data from a measurement device. 285.The method of claim 270, wherein the measurement task comprises a signalgeneration, and wherein the node is further operable to write data to ameasurement device.
 286. The method of claim 270, further comprising:the expert system validating the measurement task specification prior togenerating the run-time specification.
 287. The method of claim 270,further comprising: the run-time builder configuring one or moremeasurement devices according to the run-time specification, whereinsaid run-time executes to perform the measurement task using theconfigured one or more measurement devices.
 288. The method of claim270, wherein said graphical program comprises a LabVIEW graphicalprogram.
 289. The method of claim 270, wherein the measurement taskcomprises one or more of: one or more measurements; and one or moresignal generations.
 290. The method of claim 270, wherein themeasurement task comprises a complex measurement operation using aplurality of measurement devices, wherein at least one of the pluralityof measurement devices comprises a measurement hardware device.
 291. Themethod of claim 270, wherein the measurement task comprises a complexmeasurement operation using a plurality of measurement devices, whereinat least one of the plurality of measurement devices comprises a virtualmeasurement device.
 292. The method of claim 270, wherein saidmeasurement task specification comprises configuration information forone or more measurement devices; and wherein, after being configuredwith said configuration information, the one or more measurement devicesare operable to perform the measurement task.
 293. The method of claim270, wherein the measurement task comprises a repetitive measurementtask, the method further comprising: configuring the node to perform therepetitive measurement task;
 294. The method of claim 293, wherein saidconfiguring the node to perform the repetitive measurement taskcomprises displaying the node in a loop structure in the graphicalprogram, wherein the loop structure indicates that the node is toexecute continuously or a specified number of times.
 295. The method ofclaim 293, wherein said configuring the node to perform the repetitivemeasurement task comprises displaying a different node in the graphicalprogram which represents a repetitive measurement task parameter; andconnecting the node to the different node to indicate that the node isto execute repetitively in accordance with the repetitive measurementtask parameter.
 296. The method of claim 295, wherein said repetitivemeasurement task parameter indicates that the node is to executecontinuously.
 297. The method of claim 295, wherein said repetitivemeasurement task parameter indicates that the node is to execute aspecified number of times.
 298. The method of claim 293, furthercomprising: displaying a GUI element which is operable to controloperation of the graphical program.
 299. The method of claim 298,wherein the GUI element is operable to control start and/or stopoperations of the measurement task performed by the graphical program.300. The method of claim 298, wherein the GUI element is displayed in apanel separate from the graphical program.
 301. The method of claim 298,wherein the GUI element is displayed in the graphical program.
 302. Themethod of claim 298, further comprising: receiving first user input tosaid GUI element to invoke execution of the graphical program; andreceiving second user input to said GUI element to terminate executionof the graphical program.
 303. The method of claim 298, wherein said GUIelement comprises a toggle switch which operates to alternately controlstart and stop operations of the measurement task performed by thegraphical program.
 304. The method of claim 293, wherein the nodeinvoking execution of a program to perform the measurement taskcomprises: the node invoking two or more iteration cycles of the programto perform the measurement task; and the node performing one or moreoperations prior to or during a first iteration cycle of said two ormore iteration cycles of the program.
 305. The method of claim 293,wherein the node invoking execution of a program to perform themeasurement task comprises: the node invoking two or more iterationcycles of the program to perform the measurement task; and the nodeperforming one or more operations during or after a final iterationcycle of said two or more iteration cycles of the program.
 306. Themethod of claim 270, further comprising: receiving user input selectingthe node; and displaying a more detailed graphical program representingoperations of the node.
 307. A carrier medium comprising programinstructions for creating a graphical program that performs ameasurement task, wherein the program instructions are executable toperform: displaying a node in a graphical program; configuring the nodeto receive a measurement task specification; executing the node in thegraphical program, wherein said executing the node comprises: the nodereceiving the measurement task specification; the node invoking anexpert system to analyze the measurement task specification and generatea run-time specification for the measurement task in response to saidanalyzing; the node invoking a run-time builder to analyze the run-timespecification and generate a run-time based on the run-timespecification, wherein said run-time is executable to perform themeasurement task; and the node invoking execution of said run-time toperform the measurement task.
 308. The carrier medium of claim 307,wherein the program instructions are further executable to perform:displaying a graphical user interface (GUI) for specifying themeasurement task; receiving user input to the GUI indicating a pluralityof parameters characterizing the measurement task, wherein saidplurality of parameters is useable in generating the measurement taskspecification; and generating the measurement task specification. 309.The carrier medium of claim 307, wherein the program instructions arefurther executable to perform: generating said graphical programprogrammatically.
 310. The carrier medium of claim 307, wherein theprogram instructions are further executable to perform: receiving userinput to the GUI requesting programmatic generation of the graphicalprogram; and generating said graphical program programmatically inresponse to said user input requesting said generation.
 311. The carriermedium of claim 307, wherein said configuring the node to receive ameasurement task specification comprises connecting an input terminal ofthe node to an output terminal of different node in the graphicalprogram.
 312. The carrier medium of claim 311, wherein said differentnode is a measurement task specification node.
 313. The carrier mediumof claim 311, wherein said different node is a configuration node whichoperates to configure the measurement task specification for input tothe node.
 314. The carrier medium of claim 313, wherein saidconfiguration node operates in conjunction with one or more otherconfiguration nodes to generate the measurement task specification. 315.The carrier medium of claim 307, wherein the node is a primitive nodeprovided by a graphical programming development environment forinclusion in the graphical program.
 316. The carrier medium of claim307, wherein the node is further operable to be connected to one or moreof: a read node, which is operable to perform at least a portion of themeasurement task, wherein the measurement task comprises a measurement;and a write node, which is operable to perform at least a portion of themeasurement task, wherein the measurement task comprises a signalgeneration.
 317. The carrier medium of claim 307, wherein the node isoperable to be connected to one or more of: a read node, which isoperable to acquire data from a measurement device, wherein themeasurement task comprises a measurement; and a write node, which isoperable to write data to a measurement device, wherein the measurementtask comprises a signal generation.
 318. The carrier medium of claim307, wherein the measurement task comprises a repetitive measurementtask, wherein the node invoking execution of a program to perform themeasurement task comprises: the node invoking two or more iterationcycles of the program to perform the measurement task; and the nodeperforming one or more operations during or prior to a first iterationcycle of said two or more iteration cycles of the program.
 319. Thecarrier medium of claim 317, wherein the measurement task comprises arepetitive task, wherein the program instructions are further executableto perform: displaying a stop node in the graphical program, wherein thestop node is connected to said one or more of said read node and saidwrite node, and wherein the stop node is operable to terminate themeasurement task.
 320. The carrier medium of claim 319, wherein the nodeinvoking execution of the program to perform the measurement taskcomprises: the node invoking two or more iteration cycles of the programto perform the measurement task; and the stop node performing one ormore operations prior to or during a final iteration cycle of said twoor more iteration cycles of the program.
 321. The carrier medium ofclaim 307, wherein the measurement task comprises a measurement, andwherein the node is further operable to acquire data from a measurementdevice.
 322. The carrier medium of claim 307, wherein the measurementtask comprises a signal generation, and wherein the node is furtheroperable to write data to a measurement device.
 323. The carrier mediumof claim 307, wherein the program instructions are further executable toperform: the expert system validating the measurement task specificationprior to generating the run-time specification.
 324. The carrier mediumof claim 307, wherein the program instructions are further executable toperform: the run-time builder configuring one or more measurementdevices according to the run-time specification, wherein said run-timeexecutes to perform the measurement task using the configured one ormore measurement devices.
 325. The carrier medium of claim 307, whereinsaid graphical program comprises a LabVIEW graphical program.
 326. Thecarrier medium of claim 307, wherein the measurement task comprises oneor more of: one or more measurements; and one or more signalgenerations.
 327. The carrier medium of claim 307, wherein themeasurement task comprises a complex measurement operation using aplurality of measurement devices, wherein at least one of the pluralityof measurement devices comprises a measurement hardware device.
 328. Thecarrier medium of claim 307, wherein the measurement task comprises acomplex measurement operation using a plurality of measurement devices,wherein at least one of the plurality of measurement devices comprises avirtual measurement device.
 329. The carrier medium of claim 307,wherein said measurement task specification comprises configurationinformation for one or more measurement devices; and wherein, afterbeing configured with said configuration information, the one or moremeasurement devices are operable to perform the measurement task. 330.The carrier medium of claim 307, wherein the measurement task comprisesa repetitive measurement task, wherein the program instructions arefurther executable to perform: configuring the node to perform therepetitive measurement task;
 331. The carrier medium of claim 330,wherein said configuring the node to perform the repetitive measurementtask comprises displaying the node in a loop structure in the graphicalprogram, wherein the loop structure indicates that the node is toexecute continuously or a specified number of times.
 332. The carriermedium of claim 330, wherein said configuring the node to perform therepetitive measurement task comprises displaying a different node in thegraphical program which represents a repetitive measurement taskparameter; and connecting the node to the different node to indicatethat the node is to execute repetitively in accordance with therepetitive measurement task parameter.
 333. The carrier medium of claim332, wherein said repetitive measurement task parameter indicates thatthe node is to execute continuously.
 334. The carrier medium of claim332, wherein said repetitive measurement task parameter indicates thatthe node is to execute a specified number of times.
 335. The carriermedium of claim 330, wherein the program instructions are furtherexecutable to perform: displaying a GUI element which is operable tocontrol operation of the graphical program.
 336. The carrier medium ofclaim 335, wherein the GUI element is operable to control start and/orstop operations of the task performed by the graphical program.
 337. Thecarrier medium of claim 335, wherein the GUI element is displayed in apanel separate from the graphical program.
 338. The carrier medium ofclaim 335, wherein the GUI element is displayed in the graphicalprogram.
 339. The carrier medium of claim 335, wherein the programinstructions are further executable to perform: receiving first userinput to said GUI element to invoke execution of the graphical program;and receiving second user input to said GUI element to terminateexecution of the graphical program.
 340. The carrier medium of claim335, wherein said GUI element comprises a toggle switch which operatesto alternately control start and stop operations of the graphicalprogram.
 341. The carrier medium of claim 330, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations prior to or during a firstiteration cycle of said two or more iteration cycles of the program.342. The carrier medium of claim 330, wherein the node invokingexecution of a program to perform the task comprises: the node invokingtwo or more iteration cycles of the program to perform the task; and thenode performing one or more operations during or after a final iterationcycle of said two or more iteration cycles of the program.
 343. Thecarrier medium of claim 307, wherein the program instructions arefurther executable to perform: receiving user input selecting the node;and displaying a more detailed graphical program representing operationsof the node.
 344. A node in a graphical program which is operable to:receive a measurement task specification as input, wherein themeasurement task specification specifies a measurement task; invoke anexpert system to analyze the measurement task specification and generatea run-time specification for the measurement task in response to saidanalyzing; invoke a run-time builder to analyze the run-timespecification and generate a runtime based on the run-timespecification, wherein said run-time is executable to perform themeasurement task; and invoke execution of said run-time to perform themeasurement task.
 345. The node of claim 344, wherein said expert systemis further operable to validate the measurement task specification priorto generating the run-time specification.
 346. The node of claim 344,wherein said run-time builder is further operable to: configure one ormore measurement devices according to the run-time specification,wherein said run-time is executable to perform the measurement taskusing the configured one or more measurement devices.
 347. The node ofclaim 344, wherein the node is a primitive node provided by a graphicalprogramming development environment for inclusion in the graphicalprogram.
 348. The node of claim 344, wherein the node is furtheroperable to be connected to one or more of: a read node, which isoperable to perform at least a portion of the measurement task, whereinthe measurement task comprises a measurement; and a write node, which isoperable to perform at least a portion of the measurement task, whereinthe measurement task comprises a signal generation.
 349. The node ofclaim 344, wherein the node is further operable to be connected to oneor more of: a read node, which is operable to acquire data from ameasurement device, wherein the measurement task comprises ameasurement; and a write node, which is operable to write data to ameasurement device, wherein the measurement task comprises a signalgeneration.
 350. The node of claim 349, wherein the task comprises arepetitive task, wherein the node invoking execution of a program toperform the task comprises: the node invoking two or more iterationcycles of the program to perform the task; and the node performing oneor more operations during or prior to a first iteration cycle of saidtwo or more iteration cycles of the program.
 351. The node of claim 349,wherein the task comprises a repetitive task, and wherein the graphicalprogram further comprises: a stop node displayed in the graphicalprogram, wherein the stop node is connected to said one or more of saidread node and said write node, and wherein the stop node is operable toterminate the task.
 352. The node of claim 351, wherein the nodeinvoking execution of the program to perform the task comprises: thenode invoking two or more iteration cycles of the program to perform thetask; and the stop node performing one or more operations prior to orduring a final iteration cycle of said two or more iteration cycles ofthe program.
 353. The node of claim 344, wherein the measurement taskcomprises a measurement, and wherein the node is further operable toacquire data from a measurement device.
 354. The node of claim 344,wherein the measurement task comprises a signal generation, and whereinthe node is further operable to write data to a measurement device. 355.The node of claim 344, wherein, in being operable to receive ameasurement task specification as input, an input terminal of the nodeis operable to be connected to an output terminal of a measurement taskspecification node in said graphical program.
 356. The node of claim355, wherein, in being operable to receive a measurement taskspecification as input, an input terminal of the node is operable to beconnected to an output terminal of a configuration node, wherein saidconfiguration node is operable to configure said measurement taskspecification for input to the node.
 357. The node of claim 344, whereinthe measurement task comprises a repetitive measurement task, whereinthe node is configurable to perform the repetitive measurement task;358. The node of claim 357, wherein the node is configurable to performthe repetitive measurement task by displaying the node in a loopstructure in the graphical program, wherein the loop structure indicatesthat the node is to execute continuously or a specified number of times.359. The node of claim 357, wherein the node is configurable to performthe repetitive measurement task by: displaying a different node in thegraphical program which represents a repetitive measurement taskparameter; and connecting the node to the different node to indicatethat the node is to execute repetitively in accordance with therepetitive measurement task parameter.
 360. The node of claim 359,wherein said repetitive measurement task parameter indicates that thenode is to execute continuously.
 361. The node of claim 359, whereinsaid repetitive measurement task parameter indicates that the node is toexecute a specified number of times.
 362. The node of claim 357, whereinthe graphical program comprises: a GUI element which is operable tocontrol operation of the graphical program.
 363. The node of claim 362,wherein the GUI element is operable to control start and/or stopoperations of the task performed by the graphical program.
 364. The nodeof claim 362, wherein the GUI element is displayed in a panel separatefrom the graphical program.
 365. The node of claim 362, wherein the GUIelement is displayed in the graphical program.
 366. The node of claim362, wherein said GUI element is operable to receive first user input toinvoke execution of the graphical program; and wherein said GUI elementis further operable to receive second user input to terminate executionof the graphical program.
 367. The node of claim 362, wherein said GUIelement comprises a toggle switch which operates to alternately controlstart and stop operations of the graphical program.
 368. The node ofclaim 357, wherein the node invoking execution of a program to performthe task comprises: the node invoking two or more iteration cycles ofthe program to perform the task; and the node performing one or moreoperations prior to or during a first iteration cycle of said two ormore iteration cycles of the program.
 369. The node of claim 357,wherein the node invoking execution of a program to perform the taskcomprises: the node invoking two or more iteration cycles of the programto perform the task; and the node performing one or more operationsduring or after a final iteration cycle of said two or more iterationcycles of the program.
 370. The graphical program of claim 344, whereinthe node is operable to: receive user input selecting the node; anddisplay a more detailed graphical program representing operations of thenode.
 371. A method for creating a graphical program that performs ameasurement task, the method comprising: displaying a first node in agraphical program; configuring the first node to receive a measurementtask specification; displaying a read node in the graphical program;connecting the first node to the read node; and executing the graphicalprogram, wherein said executing comprises: the first node receiving ameasurement task specification as input, wherein the measurement taskspecification specifies a measurement task; the first node invokingexecution of a program to perform the measurement task; the programexecuting to configure a measurement device to acquire data from asource; and the read node acquiring data from the measurement device.372. The method of claim 371, wherein the method operates in ameasurement system comprising a computer system and the measurementdevice; and wherein the read node acquiring data from the measurementdevice comprises the read node acquiring data from the measurementdevice and providing the acquired data to the computer system.
 373. Themethod of claim 371, further comprising: the first node generating aprogram which is operable to perform the measurement task, wherein thefirst node generates the program based on the measurement taskspecification.
 374. The method of claim 373, wherein the first nodegenerating the program comprises: the first node invoking an expertsystem to analyze the measurement task specification; and the first nodegenerating a program based on results of the expert system, wherein theprogram is operable to perform the measurement task.
 375. The method ofclaim 373, wherein the first node generating the program comprises: thefirst node invoking an expert system to analyze the measurement taskspecification and generate a run-time specification for the measurementtask in response to said analyzing; and the first node invoking arun-time builder to analyze the run-time specification and generate arun-time based on the run-time specification, wherein the run-time isexecutable to perform the measurement task.
 376. The method of claim375, wherein the first node invoking execution of the program to performthe measurement task comprises the first node invoking execution of therun-time to perform the measurement task.
 377. The method of claim 375,wherein the first node generating the program further comprises: theexpert system validating the measurement task specification prior togenerating the run-time specification.
 378. The method of claim 375,wherein the first node generating the program further comprises: therun-time builder configuring one or more measurement devices accordingto the run-time specification, wherein said run-time executes to performthe measurement task using the configured one or more measurementdevices.
 379. The method of claim 371, further comprising: displaying astop node in the graphical program; and connecting the stop node to theread node; wherein said executing the graphical program furthercomprises: the stop node terminating the measurement task after saidread node acquiring data from the measurement device.
 380. The method ofclaim 371, further comprising: displaying at least one configurationnode in the graphical program; wherein configuring the first node toreceive a measurement task specification comprises: connecting the atleast one configuration node to the first node, wherein the at least oneconfiguration node is operable to generate the measurement taskspecification based on user-specified parameters; wherein said executingthe graphical program further comprises: the at least one configurationnode generating the measurement task specification for input to thefirst node.
 381. A carrier medium comprising program instructions forcreating a graphical program that performs a measurement task, whereinthe program instructions are executable to perform: displaying a firstnode in a graphical program; configuring the first node to receive ameasurement task specification; displaying a read node in the graphicalprogram; connecting the first node to the read node; and executing thegraphical program, wherein said executing comprises: the first nodereceiving a measurement task specification as input, wherein themeasurement task specification specifies a measurement task; the firstnode invoking execution of a program to perform the measurement task;the program executing to configure a measurement device to acquire datafrom a source; and the read node acquiring data from the measurementdevice.
 382. The carrier medium of claim 381, wherein the programinstructions implement a portion of a measurement system comprising acomputer system and the measurement device; and wherein the read nodeacquiring data from the measurement device comprises the read nodeacquiring data from the measurement device and providing the acquireddata to the computer system.
 383. The carrier medium of claim 381,wherein the program instructions are further executable to perform: thefirst node generating a program which is operable to perform themeasurement task, wherein the first node generates the program based onthe measurement task specification.
 384. The carrier medium of claim383, wherein the first node generating the program comprises: the firstnode invoking an expert system to analyze the measurement taskspecification; and the first node generating a program based on resultsof the expert system, wherein the program is operable to perform themeasurement task.
 385. The carrier medium of claim 383, wherein thefirst node generating the program comprises: the first node invoking anexpert system to analyze the measurement task specification and generatea run-time specification for the measurement task in response to saidanalyzing; and the first node invoking a run-time builder to analyze therun-time specification and generate a run-time based on the run-timespecification, wherein the run-time is executable to perform themeasurement task.
 386. The carrier medium of claim 385, wherein thefirst node invoking execution of the program to perform the measurementtask comprises the first node invoking execution of the run-time toperform the measurement task.
 387. The carrier medium of claim 385,wherein the first node generating the program further comprises: theexpert system validating the measurement task specification prior togenerating the run-time specification.
 388. The carrier medium of claim385, wherein the first node generating the program further comprises:the run-time builder configuring one or more measurement devicesaccording to the run-time specification, wherein said run-time executesto perform the measurement task using the configured one or moremeasurement devices.
 389. The carrier medium of claim 381, wherein theprogram instructions are further executable to perform: displaying astop node in the graphical program; and connecting the stop node to theread node; wherein said executing the graphical program furthercomprises: the stop node terminating the measurement task after saidread node acquiring data from the measurement device.
 390. The carriermedium of claim 381, wherein the program instructions are furtherexecutable to perform: displaying at least one configuration node in thegraphical program; wherein configuring the first node to receive ameasurement task specification comprises: connecting the at least oneconfiguration node to the first node, wherein the at least oneconfiguration node is operable to generate the measurement taskspecification based on user-specified parameters; wherein said executingthe graphical program further comprises: the at least one configurationnode generating the measurement task specification for input to thefirst node.
 391. A method for creating a graphical program that performsa measurement task, the method comprising: displaying a first node in agraphical program; configuring the first node to receive a measurementtask specification; displaying a write node in the graphical program;connecting the first node to the write node; and executing the graphicalprogram, wherein said executing comprises: the first node receiving ameasurement task specification as input, wherein the measurement taskspecification specifies a measurement task; the first node invokingexecution of a program to perform the measurement task; the programexecuting to configure a measurement device to generate a signal; andthe write node invoking signal generation by the measurement device.392. The method of claim 391, wherein the method operates in ameasurement system comprising a computer system and the measurementdevice.
 393. The method of claim 391, further comprising: the first nodegenerating a program which is operable to perform the measurement task,wherein the first node generates the program based on the measurementtask specification.
 394. The method of claim 393, wherein the first nodegenerating the program comprises: the first node invoking an expertsystem to analyze the measurement task specification; and the first nodegenerating a program based on results of the expert system, wherein theprogram is operable to perform the measurement task.
 395. The method ofclaim 393, wherein the first node generating the program comprises: thefirst node invoking an expert system to analyze the measurement taskspecification and generate a run-time specification for the measurementtask in response to said analyzing; and the first node invoking arun-time builder to analyze the run-time specification and generate arun-time based on the run-time specification, wherein the run-time isexecutable to perform the measurement task.
 396. The method of claim395, wherein the first node invoking execution of the program to performthe measurement task comprises the first node invoking execution of therun-time to perform the measurement task.
 397. The method of claim 395,wherein the first node generating the program further comprises: theexpert system validating the measurement task specification prior togenerating the run-time specification.
 398. The method of claim 395,wherein the first node generating the program further comprises: therun-time builder configuring one or more measurement devices accordingto the run-time specification, wherein said run-time executes to performthe measurement task using the configured one or more measurementdevices.
 399. The method of claim 391, further comprising: displaying astop node in the graphical program; and connecting the stop node to thewrite node; wherein said executing the graphical program furthercomprises: the stop node terminating the measurement task after saidwrite node invoking signal generation by the measurement device. 400.The method of claim 391, further comprising: displaying at least oneconfiguration node in the graphical program; wherein configuring thefirst node to receive a measurement task specification comprises:connecting the at least one configuration node to the first node,wherein the at least one configuration node is operable to generate themeasurement task specification based on user-specified parameters; andwherein said executing the graphical program further comprises: the atleast one configuration node generating the measurement taskspecification for input to the first node.
 401. A carrier mediumcomprising program instructions for creating a graphical program thatperforms a measurement task, wherein the program instructions areexecutable to perform: displaying a first node in a graphical program;configuring the first node to receive a measurement task specification;displaying a write node in the graphical program; connecting the firstnode to the write node; and executing the graphical program, whereinsaid executing comprises: the first node receiving a measurement taskspecification as input, wherein the measurement task specificationspecifies a measurement task; the first node invoking execution of aprogram to perform the measurement task; the program executing toconfigure a measurement device to generate a signal; and the write nodeinvoking signal generation by the measurement device.
 402. The carriermedium of claim 401, wherein the program instructions implement aportion of a measurement system comprising a computer system and themeasurement device.
 403. The carrier medium of claim 401, wherein theprogram instructions are further executable to perform: the first nodegenerating a program which is operable to perform the measurement task,wherein the first node generates the program based on the measurementtask specification.
 404. The carrier medium of claim 403, wherein thefirst node generating the program comprises: the first node invoking anexpert system to analyze the measurement task specification; and thefirst node generating a program based on results of the expert system,wherein the program is operable to perform the measurement task. 405.The carrier medium of claim 403, wherein the first node generating theprogram comprises: the first node invoking an expert system to analyzethe measurement task specification and generate a run-time specificationfor the measurement task in response to said analyzing; and the firstnode invoking a run-time builder to analyze the run-time specificationand generate a run-time based on the run-time specification, wherein therun-time is executable to perform the measurement task.
 406. The carriermedium of claim 405, wherein the first node invoking execution of theprogram to perform the measurement task comprises the first nodeinvoking execution of the run-time to perform the measurement task. 407.The carrier medium of claim 405, wherein the first node generating theprogram further comprises: the expert system validating the measurementtask specification prior to generating the run-time specification. 408.The carrier medium of claim 405, wherein the first node generating theprogram further comprises: the run-time builder configuring one or moremeasurement devices according to the run-time specification, whereinsaid run-time executes to perform the measurement task using theconfigured one or more measurement devices.
 409. The carrier medium ofclaim 401, wherein the program instructions are further executable toperform: displaying a stop node in the graphical program; and connectingthe stop node to the write node; wherein said executing the graphicalprogram further comprises: the stop node terminating the measurementtask after said write node invoking signal generation by the measurementdevice.
 410. The carrier medium of claim 401, wherein the programinstructions are further executable to perform: displaying at least oneconfiguration node in the graphical program; wherein configuring thefirst node to receive a measurement task specification comprises:connecting the at least one configuration node to the first node,wherein the at least one configuration node is operable to generate themeasurement task specification based on user-specified parameters; andwherein said executing the graphical program further comprises: the atleast one configuration node generating the measurement taskspecification for input to the first node.